diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationScenariosTest.java index bff57b59..8556d3a1 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationScenariosTest.java @@ -1,5 +1,6 @@ package uk.gov.hmcts.reform.em.annotation.functional; +import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; import io.restassured.response.ValidatableResponse; @@ -8,25 +9,60 @@ import org.json.JSONArray; import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.is; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.ANNOTATION_TYPE_HIGHLIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATIONS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.COLOR_DEFAULT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.COLOR_SECOND_UPDATE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.COLOR_UPDATED; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.COMMENT_TEXT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_SET_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_TYPE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_CASE_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COLOR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COMMENTS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COMMENT_HEADER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_HEIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_JURISDICTION; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_RECTANGLES; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_WIDTH; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_X; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_Y; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.LOCATION_HEADER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.PUBLIC_LAW; class AnnotationScenariosTest extends BaseTest { private final ObjectMapper objectMapper = new ObjectMapper().registerModule(new JavaTimeModule()); - public final String caseData = """ + + // 🔹 Test data JSON + public static final String CASE_DATA = """ { "caseTitle": "title", "caseOwner": "owner", "caseCreationDate": null, "caseDescription": null, "caseComments": null - }"""; + }"""; + + @Autowired + public AnnotationScenariosTest(TestUtil testUtil) { + super(testUtil); + } @Test void shouldReturn201WhenCreateNewAnnotation() { @@ -36,77 +72,78 @@ void shouldReturn201WhenCreateNewAnnotation() { response .statusCode(201) - .body("id", equalTo(annotationId)) - .body("page", is(1)) - .body("color", is("d1d1d1")) - .body("comments", Matchers.hasSize(1)) - .body("comments[0].content", is("text")) - .body("comments[0].annotationId", is(annotationId)) - .body("rectangles", Matchers.hasSize(1)) - .body("rectangles[0].annotationId", is(annotationId)) - .body("rectangles[0].x", is(0f)) - .body("rectangles[0].y", is(0f)) - .body("rectangles[0].width", is(10f)) - .body("rectangles[0].height", is(11f)) - .header("Location", equalTo("/api/annotations/" + annotationId)) + .body(FIELD_ID, equalTo(annotationId)) + .body(FIELD_PAGE, is(1)) + .body(FIELD_COLOR, is(COLOR_DEFAULT)) + .body(FIELD_COMMENTS, Matchers.hasSize(1)) + .body(FIELD_COMMENTS + "[0]." + FIELD_CONTENT, is(COMMENT_TEXT)) + .body(FIELD_COMMENTS + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES, Matchers.hasSize(1)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_X, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_Y, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_WIDTH, is(10f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_HEIGHT, is(11f)) + .header(LOCATION_HEADER, equalTo(API_ANNOTATIONS + "/" + annotationId)) .log().all(); - } @Test - void shouldReturn201WhenCreateNewAnnotationWithCaseId() throws Exception { - CaseDetails caseDetails = testUtil.createCase("PUBLICLAW", "CCD_BUNDLE_MVP_TYPE_ASYNC", - objectMapper.readTree(caseData)); + void shouldReturn201WhenCreateNewAnnotationWithCaseId() throws JsonProcessingException { + CaseDetails caseDetails = testUtil.createCase( + PUBLIC_LAW, + "CCD_BUNDLE_MVP_TYPE_ASYNC", + objectMapper.readTree(CASE_DATA) + ); String caseId = String.valueOf(caseDetails.getId()); final String annotationSetId = createAnnotationSet(); final String annotationId = UUID.randomUUID().toString(); JSONObject annotation = createAnnotationPayload(annotationId, annotationSetId); - - annotation.put("jurisdiction", "PUBLICLAW"); - annotation.put("caseId", caseId); + annotation.put(FIELD_JURISDICTION, PUBLIC_LAW); + annotation.put(FIELD_CASE_ID, caseId); final ValidatableResponse response = request - .body(annotation) - .post("/api/annotations") - .then() - .statusCode(201) - .log().all(); + .body(annotation) + .post(API_ANNOTATIONS) + .then() + .statusCode(201) + .log().all(); response - .statusCode(201) - .body("id", equalTo(annotationId)) - .body("page", is(1)) - .body("color", is("d1d1d1")) - .body("comments", Matchers.hasSize(1)) - .body("comments[0].content", is("text")) - .body("comments[0].annotationId", is(annotationId)) - .body("rectangles", Matchers.hasSize(1)) - .body("rectangles[0].annotationId", is(annotationId)) - .body("rectangles[0].x", is(0f)) - .body("rectangles[0].y", is(0f)) - .body("rectangles[0].width", is(10f)) - .body("rectangles[0].height", is(11f)) - .body("caseId", is(caseId)) - .body("jurisdiction", is("PUBLICLAW")) - .body("commentHeader", is("title owner")) - .header("Location", equalTo("/api/annotations/" + annotationId)).log().all(); - + .statusCode(201) + .body(FIELD_ID, equalTo(annotationId)) + .body(FIELD_PAGE, is(1)) + .body(FIELD_COLOR, is(COLOR_DEFAULT)) + .body(FIELD_COMMENTS, Matchers.hasSize(1)) + .body(FIELD_COMMENTS + "[0]." + FIELD_CONTENT, is(COMMENT_TEXT)) + .body(FIELD_COMMENTS + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES, Matchers.hasSize(1)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_X, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_Y, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_WIDTH, is(10f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_HEIGHT, is(11f)) + .body(FIELD_CASE_ID, is(caseId)) + .body(FIELD_JURISDICTION, is(PUBLIC_LAW)) + .body(FIELD_COMMENT_HEADER, is("title owner")) + .header(LOCATION_HEADER, equalTo(API_ANNOTATIONS + "/" + annotationId)) + .log().all(); } @Test void shouldReturn400WhenCreateNewAnnotationWithBadPayload() { - final String newAnnotationSetId = createAnnotationSet(); + final String annotationSetId = createAnnotationSet(); final JSONObject annotation = new JSONObject(); - annotation.put("annotationSetId", newAnnotationSetId); - annotation.put("annotationType", "highlight"); - annotation.put("page", 1); - annotation.put("color", "d1d1d1"); + annotation.put(FIELD_ANNOTATION_SET_ID, annotationSetId); + annotation.put(FIELD_ANNOTATION_TYPE, ANNOTATION_TYPE_HIGHLIGHT); + annotation.put(FIELD_PAGE, 1); + annotation.put(FIELD_COLOR, COLOR_DEFAULT); request .body(annotation) - .post("/api/annotations") + .post(API_ANNOTATIONS) .then() .statusCode(400) .log().all(); @@ -114,19 +151,19 @@ void shouldReturn400WhenCreateNewAnnotationWithBadPayload() { @Test void shouldReturn401WhenUnAuthenticatedUserCreateNewAnnotation() { - final String newAnnotationSetId = UUID.randomUUID().toString(); + final String annotationSetId = UUID.randomUUID().toString(); final String annotationId = UUID.randomUUID().toString(); - final JSONObject createAnnotations = new JSONObject(); - createAnnotations.put("id", annotationId); - createAnnotations.put("annotationSetId", newAnnotationSetId); - createAnnotations.put("annotationType", "highlight"); - createAnnotations.put("page", 1); - createAnnotations.put("color", "d1d1d1"); + final JSONObject annotation = new JSONObject(); + annotation.put(FIELD_ID, annotationId); + annotation.put(FIELD_ANNOTATION_SET_ID, annotationSetId); + annotation.put(FIELD_ANNOTATION_TYPE, ANNOTATION_TYPE_HIGHLIGHT); + annotation.put(FIELD_PAGE, 1); + annotation.put(FIELD_COLOR, COLOR_DEFAULT); unAuthenticatedRequest - .body(createAnnotations.toString()) - .post("/api/annotations") + .body(annotation.toString()) + .post(API_ANNOTATIONS) .then() .statusCode(401) .log().all(); @@ -137,24 +174,24 @@ void shouldReturn200WhenGetAnnotationById() { final String annotationSetId = createAnnotationSet(); final String annotationId = UUID.randomUUID().toString(); final ValidatableResponse response = createAnnotation(annotationId, annotationSetId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); request - .get("/api/annotations/" + id) + .get(API_ANNOTATIONS + "/" + id) .then() .statusCode(200) - .body("id", equalTo(annotationId)) - .body("page", is(1)) - .body("color", is("d1d1d1")) - .body("comments", Matchers.hasSize(1)) - .body("comments[0].content", is("text")) - .body("comments[0].annotationId", is(annotationId)) - .body("rectangles", Matchers.hasSize(1)) - .body("rectangles[0].annotationId", is(annotationId)) - .body("rectangles[0].x", is(0f)) - .body("rectangles[0].y", is(0f)) - .body("rectangles[0].width", is(10f)) - .body("rectangles[0].height", is(11f)) + .body(FIELD_ID, equalTo(annotationId)) + .body(FIELD_PAGE, is(1)) + .body(FIELD_COLOR, is(COLOR_DEFAULT)) + .body(FIELD_COMMENTS, Matchers.hasSize(1)) + .body(FIELD_COMMENTS + "[0]." + FIELD_CONTENT, is(COMMENT_TEXT)) + .body(FIELD_COMMENTS + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES, Matchers.hasSize(1)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_ANNOTATION_ID, is(annotationId)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_X, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_Y, is(0f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_WIDTH, is(10f)) + .body(FIELD_RECTANGLES + "[0]." + FIELD_HEIGHT, is(11f)) .log().all(); } @@ -162,7 +199,7 @@ void shouldReturn200WhenGetAnnotationById() { void shouldReturn404WhenGetAnnotationNotFoundById() { final String annotationId = UUID.randomUUID().toString(); request - .get("/api/annotations/" + annotationId) + .get(API_ANNOTATIONS + "/" + annotationId) .then() .statusCode(404) .log().all(); @@ -172,7 +209,7 @@ void shouldReturn404WhenGetAnnotationNotFoundById() { void shouldReturn401WhenUnAuthenticatedUserGetAnnotationById() { final String annotationId = UUID.randomUUID().toString(); unAuthenticatedRequest - .get("/api/annotations/" + annotationId) + .get(API_ANNOTATIONS + "/" + annotationId) .then() .statusCode(401) .log().all(); @@ -185,7 +222,7 @@ void shouldReturn200WhenGetAllAnnotations() { createAnnotation(annotationId, annotationSetId); request - .get("/api/annotations") + .get(API_ANNOTATIONS) .then() .statusCode(200) .body("size()", Matchers.greaterThanOrEqualTo(1)) @@ -195,7 +232,7 @@ void shouldReturn200WhenGetAllAnnotations() { @Test void shouldReturn401WhenUnAuthenticatedUserGetAllAnnotations() { unAuthenticatedRequest - .get("/api/annotations") + .get(API_ANNOTATIONS) .then() .statusCode(401) .log().all(); @@ -207,21 +244,21 @@ void shouldReturn200WhenUpdateAnnotation() { final String annotationId = UUID.randomUUID().toString(); final ValidatableResponse response = createAnnotation(annotationId, annotationSetId); final JSONObject annotation = extractJsonObjectFromResponse(response); - annotation.put("page", 2); - annotation.put("color", "f1f1f1"); + annotation.put(FIELD_PAGE, 2); + annotation.put(FIELD_COLOR, COLOR_UPDATED); request .body(annotation.toString()) - .put("/api/annotations") + .put(API_ANNOTATIONS) .then() .statusCode(200) - .body("id", equalTo(annotationId)) - .body("page", is(2)) - .body("color", is("f1f1f1")) - .body("comments", Matchers.hasSize(1)) + .body(FIELD_ID, equalTo(annotationId)) + .body(FIELD_PAGE, is(2)) + .body(FIELD_COLOR, is(COLOR_UPDATED)) + .body(FIELD_COMMENTS, Matchers.hasSize(1)) .body("comments[0].content", is("text")) .body("comments[0].annotationId", is(annotationId)) - .body("rectangles", Matchers.hasSize(1)) + .body(FIELD_RECTANGLES, Matchers.hasSize(1)) .body("rectangles[0].annotationId", is(annotationId)) .body("rectangles[0].x", is(0f)) .body("rectangles[0].y", is(0f)) @@ -236,18 +273,16 @@ void shouldReturn400WhenUpdateAnnotationWithoutId() { final String annotationId = UUID.randomUUID().toString(); final ValidatableResponse response = createAnnotation(annotationId, annotationSetId); final JSONObject annotation = extractJsonObjectFromResponse(response); - - annotation.remove("id"); + annotation.remove(FIELD_ID); request .body(annotation.toString()) - .put("/api/annotations") + .put(API_ANNOTATIONS) .then() .statusCode(400) .log().all(); } - @Test void shouldReturn401WhenUnAuthenticatedUserUpdateAnnotation() { final String annotationSetId = createAnnotationSet(); @@ -257,7 +292,7 @@ void shouldReturn401WhenUnAuthenticatedUserUpdateAnnotation() { unAuthenticatedRequest .body(annotation.toString()) - .put("/api/annotations") + .put(API_ANNOTATIONS) .then() .statusCode(401) .log().all(); @@ -268,25 +303,20 @@ void shouldReturn200WhenDeleteAnnotationById() { final String annotationSetId = createAnnotationSet(); final String annotationId = UUID.randomUUID().toString(); final ValidatableResponse response = createAnnotation(annotationId, annotationSetId); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); - final String id = extractJsonObjectFromResponse(response).getString("id"); - final ValidatableResponse deletedResponse = deleteAnnotationById(id); - - deletedResponse.statusCode(200); + deleteAnnotationById(id).statusCode(200); } @Test void shouldReturn200WhenDeleteAnnotationByNonExistentId() { - final String nonExistentAnnotationId = UUID.randomUUID().toString(); - final ValidatableResponse deletedResponse = deleteAnnotationById(nonExistentAnnotationId); - - deletedResponse.statusCode(200); + deleteAnnotationById(UUID.randomUUID().toString()).statusCode(200); } @Test void shouldReturn401WhenUnAuthenticatedUserDeleteAnnotation() { unAuthenticatedRequest - .delete("/api/annotations/" + UUID.randomUUID()) + .delete(API_ANNOTATIONS + "/" + UUID.randomUUID()) .then() .statusCode(401) .log().all(); @@ -297,21 +327,21 @@ void shouldReturn200WhenUpdateAnnotationAfterItHasBeenDeleted() { final String annotationSetId = createAnnotationSet(); final String annotationId = UUID.randomUUID().toString(); final ValidatableResponse response = createAnnotation(annotationId, annotationSetId); - final JSONObject annotation = extractJsonObjectFromResponse(response); - final String id = annotation.getString("id"); + final String id = annotation.getString(FIELD_ID); + deleteAnnotationById(id).statusCode(200); - annotation.put("page", 3); - annotation.put("color", "e1e1e1"); + annotation.put(FIELD_PAGE, 3); + annotation.put(FIELD_COLOR, COLOR_SECOND_UPDATE); request .body(annotation.toString()) - .put("/api/annotations") + .put(API_ANNOTATIONS) .then() .statusCode(200) - .body("id", equalTo(annotationId)) - .body("page", is(3)) - .body("color", is("e1e1e1")) + .body(FIELD_ID, equalTo(annotationId)) + .body(FIELD_PAGE, is(3)) + .body(FIELD_COLOR, is(COLOR_SECOND_UPDATE)) .body("comments", Matchers.hasSize(1)) .body("comments[0].content", is("text")) .body("comments[0].annotationId", is(annotationId)) @@ -327,7 +357,7 @@ void shouldReturn200WhenUpdateAnnotationAfterItHasBeenDeleted() { @NotNull private ValidatableResponse deleteAnnotationById(String annotationId) { return request - .delete("/api/annotations/" + annotationId) + .delete(API_ANNOTATIONS + "/" + annotationId) .then() .log().all(); } @@ -336,20 +366,20 @@ private ValidatableResponse deleteAnnotationById(String annotationId) { private String createAnnotationSet() { final JSONObject jsonObject = new JSONObject(); final UUID newAnnotationSetId = UUID.randomUUID(); - jsonObject.put("documentId", UUID.randomUUID().toString()); - jsonObject.put("id", newAnnotationSetId.toString()); + jsonObject.put(FIELD_DOCUMENT_ID, UUID.randomUUID().toString()); + jsonObject.put(FIELD_ID, newAnnotationSetId.toString()); return request .body(jsonObject.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .statusCode(201) - .body("id", equalTo(newAnnotationSetId.toString())) + .body(FIELD_ID, equalTo(newAnnotationSetId.toString())) .extract() .response() .getBody() .jsonPath() - .get("id"); + .get(FIELD_ID); } @NotNull @@ -357,7 +387,7 @@ private ValidatableResponse createAnnotation(String annotationId, String annotat final JSONObject annotation = createAnnotationPayload(annotationId, annotationSetId); return request .body(annotation) - .post("/api/annotations") + .post(API_ANNOTATIONS) .then() .statusCode(201) .log().all(); @@ -366,30 +396,30 @@ private ValidatableResponse createAnnotation(String annotationId, String annotat @NotNull private JSONObject createAnnotationPayload(String annotationId, String annotationSetId) { final JSONObject createAnnotations = new JSONObject(); - createAnnotations.put("annotationSetId", annotationSetId); - createAnnotations.put("id", annotationId); - createAnnotations.put("annotationType", "highlight"); - createAnnotations.put("page", 1); - createAnnotations.put("color", "d1d1d1"); + createAnnotations.put(FIELD_ANNOTATION_SET_ID, annotationSetId); + createAnnotations.put(FIELD_ID, annotationId); + createAnnotations.put(FIELD_ANNOTATION_TYPE, ANNOTATION_TYPE_HIGHLIGHT); + createAnnotations.put(FIELD_PAGE, 1); + createAnnotations.put(FIELD_COLOR, COLOR_DEFAULT); final JSONArray comments = new JSONArray(); final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("annotationId", annotationId); - comment.put("id", UUID.randomUUID().toString()); - comments.put(0, comment); - createAnnotations.put("comments", comments); + comment.put(FIELD_CONTENT, COMMENT_TEXT); + comment.put(FIELD_ANNOTATION_ID, annotationId); + comment.put(FIELD_ID, UUID.randomUUID().toString()); + comments.put(comment); + createAnnotations.put(FIELD_COMMENTS, comments); final JSONArray rectangles = new JSONArray(); final JSONObject rectangle = new JSONObject(); - rectangle.put("id", UUID.randomUUID().toString()); - rectangle.put("annotationId", annotationId); - rectangle.put("x", 0f); - rectangle.put("y", 0f); - rectangle.put("width", 10f); - rectangle.put("height", 11f); - rectangles.put(0, rectangle); - createAnnotations.put("rectangles", rectangles); + rectangle.put(FIELD_ID, UUID.randomUUID().toString()); + rectangle.put(FIELD_ANNOTATION_ID, annotationId); + rectangle.put(FIELD_X, 0f); + rectangle.put(FIELD_Y, 0f); + rectangle.put(FIELD_WIDTH, 10f); + rectangle.put(FIELD_HEIGHT, 11f); + rectangles.put(rectangle); + createAnnotations.put(FIELD_RECTANGLES, rectangles); return createAnnotations; } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationSetScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationSetScenariosTest.java index 2f08d751..48da57f7 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationSetScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/AnnotationSetScenariosTest.java @@ -6,15 +6,39 @@ import org.json.JSONArray; import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.Matchers.hasSize; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATIONS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATIONS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_SET_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_TYPE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COLOR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COMMENTS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_RECTANGLES; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.HEADER_LOCATION; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.VALUE_COLOR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.VALUE_HIGHLIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.VALUE_TEXT; class AnnotationSetScenariosTest extends BaseTest { + @Autowired + public AnnotationSetScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test void shouldReturn201WhenCreateNewAnnotationSet() { final UUID annotationSetId = UUID.randomUUID(); @@ -23,9 +47,9 @@ void shouldReturn201WhenCreateNewAnnotationSet() { response .statusCode(201) - .body("documentId", equalTo(documentId.toString())) - .body("id", equalTo(annotationSetId.toString())) - .header("Location", equalTo("/api/annotation-sets/" + annotationSetId)) + .body(FIELD_DOCUMENT_ID, equalTo(documentId.toString())) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .header(HEADER_LOCATION, equalTo(API_ANNOTATION_SETS + "/" + annotationSetId)) .log().all(); } @@ -33,11 +57,11 @@ void shouldReturn201WhenCreateNewAnnotationSet() { void shouldReturn400WhenCreateNewAnnotationSetWithoutId() { final JSONObject annotationSet = new JSONObject(); final UUID documentId = UUID.randomUUID(); - annotationSet.put("documentId", documentId); + annotationSet.put(FIELD_DOCUMENT_ID, documentId); request .body(annotationSet.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .statusCode(400) .log().all(); @@ -48,12 +72,12 @@ void shouldReturn401WhenUnAuthenticatedUserCreateNewAnnotationSet() { final JSONObject annotationSet = new JSONObject(); final UUID annotationSetId = UUID.randomUUID(); final UUID documentId = UUID.randomUUID(); - annotationSet.put("documentId", documentId); - annotationSet.put("id", annotationSetId.toString()); + annotationSet.put(FIELD_DOCUMENT_ID, documentId); + annotationSet.put(FIELD_ID, annotationSetId.toString()); unAuthenticatedRequest .body(annotationSet.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .statusCode(401) .log().all(); @@ -65,14 +89,14 @@ void shouldReturn200WhenGetAnnotationSetById() { final UUID documentId = UUID.randomUUID(); final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); final JSONObject annotationSet = extractJsonObjectFromResponse(response); - final String id = annotationSet.getString("id"); + final String id = annotationSet.getString(FIELD_ID); request - .get("/api/annotation-sets/" + id) + .get(API_ANNOTATION_SETS + "/" + id) .then() .statusCode(200) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", is(documentId.toString())) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, is(documentId.toString())) .log().all(); } @@ -81,7 +105,7 @@ void shouldReturn204WhenGetAnnotationSetNotFoundById() { final String annotationSetId = UUID.randomUUID().toString(); request - .get("/api/annotation-sets/" + annotationSetId) + .get(API_ANNOTATION_SETS + "/" + annotationSetId) .then() .statusCode(204) .log().all(); @@ -92,7 +116,7 @@ void shouldReturn401WhenUnAuthenticatedUserGetAnnotationSetById() { final String annotationSetId = UUID.randomUUID().toString(); unAuthenticatedRequest - .get("/api/annotation-sets/" + annotationSetId) + .get(API_ANNOTATION_SETS + "/" + annotationSetId) .then() .statusCode(401) .log().all(); @@ -105,7 +129,7 @@ void shouldReturn200WhenGetAllAnnotationSets() { createAnnotationSet(annotationSetId, documentId); request - .get("/api/annotation-sets") + .get(API_ANNOTATION_SETS) .then() .statusCode(200) .body("size()", Matchers.greaterThanOrEqualTo(1)) @@ -115,7 +139,7 @@ void shouldReturn200WhenGetAllAnnotationSets() { @Test void shouldReturn401WhenUnAuthenticatedUserGetAllAnnotationSets() { unAuthenticatedRequest - .get("/api/annotation-sets") + .get(API_ANNOTATION_SETS) .then() .statusCode(401) .log().all(); @@ -128,15 +152,15 @@ void shouldReturn200WhenUpdateAnnotationSet() { final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); final JSONObject annotationSet = extractJsonObjectFromResponse(response); final UUID newDocumentId = UUID.randomUUID(); - annotationSet.put("documentId", newDocumentId); + annotationSet.put(FIELD_DOCUMENT_ID, newDocumentId); request .body(annotationSet.toString()) - .put("/api/annotation-sets") + .put(API_ANNOTATION_SETS) .then() .statusCode(200) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", is(newDocumentId.toString())) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, is(newDocumentId.toString())) .log().all(); } @@ -147,21 +171,21 @@ void shouldReturn200WhenUpdateAnnotationSetWithNewAnnotation() { final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); final JSONObject annotationSet = extractJsonObjectFromResponse(response); final UUID newDocumentId = UUID.randomUUID(); - annotationSet.put("documentId", newDocumentId); - JSONArray annotations = annotationSet.getJSONArray("annotations"); + annotationSet.put(FIELD_DOCUMENT_ID, newDocumentId); + JSONArray annotations = annotationSet.getJSONArray(FIELD_ANNOTATIONS); annotations.put(1, extractJsonObjectFromResponse( - createAnnotation(UUID.randomUUID().toString(), annotationSetId.toString()))); - annotationSet.put("annotations", annotations); + createAnnotation(UUID.randomUUID().toString(), annotationSetId.toString()))); + annotationSet.put(FIELD_ANNOTATIONS, annotations); request - .body(annotationSet.toString()) - .put("/api/annotation-sets") - .then() - .statusCode(200) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", is(newDocumentId.toString())) - .body("annotations", hasSize(2)) - .log().all(); + .body(annotationSet.toString()) + .put(API_ANNOTATION_SETS) + .then() + .statusCode(200) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, is(newDocumentId.toString())) + .body(FIELD_ANNOTATIONS, hasSize(2)) + .log().all(); } @Test @@ -170,11 +194,11 @@ void shouldReturn400WhenUpdateAnnotationSetWithoutId() { final UUID documentId = UUID.randomUUID(); final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); final JSONObject annotationSet = extractJsonObjectFromResponse(response); - annotationSet.remove("id"); + annotationSet.remove(FIELD_ID); request .body(annotationSet.toString()) - .put("/api/annotation-sets") + .put(API_ANNOTATION_SETS) .then() .statusCode(400) .log().all(); @@ -187,11 +211,11 @@ void shouldReturn401WhenUnAuthenticatedUserUpdateAnnotationSet() { final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); final JSONObject annotationSet = extractJsonObjectFromResponse(response); final UUID newDocumentId = UUID.randomUUID(); - annotationSet.put("documentId", newDocumentId); + annotationSet.put(FIELD_DOCUMENT_ID, newDocumentId); unAuthenticatedRequest .body(annotationSet.toString()) - .put("/api/annotation-sets") + .put(API_ANNOTATION_SETS) .then() .statusCode(401) .log().all(); @@ -202,7 +226,7 @@ void shouldReturn200WhenDeleteAnnotationSetById() { final UUID annotationSetId = UUID.randomUUID(); final UUID documentId = UUID.randomUUID(); final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); final ValidatableResponse deletedResponse = deleteAnnotationSetById(id); deletedResponse.statusCode(200); @@ -219,7 +243,7 @@ void shouldReturn200WhenDeleteAnnotationSetByNonExistentId() { @Test void shouldReturn401WhenUnAuthenticatedUserDeleteAnnotationSet() { unAuthenticatedRequest - .delete("/api/annotation-sets/" + UUID.randomUUID()) + .delete(API_ANNOTATION_SETS + "/" + UUID.randomUUID()) .then() .statusCode(401) .log().all(); @@ -231,26 +255,28 @@ void shouldReturn200WhenUpdateAnnotationSetAfterItHasBeenDeleted() { final UUID documentId = UUID.randomUUID(); final UUID newDocumentId = UUID.randomUUID(); final ValidatableResponse response = createAnnotationSet(annotationSetId, documentId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); final JSONObject annotationSet = extractJsonObjectFromResponse(response); deleteAnnotationSetById(id).statusCode(200); - annotationSet.put("documentId", newDocumentId); + annotationSet.put(FIELD_DOCUMENT_ID, newDocumentId); request .body(annotationSet.toString()) - .put("/api/annotation-sets") + .put(API_ANNOTATION_SETS) .then() .statusCode(200) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", is(newDocumentId.toString())) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, is(newDocumentId.toString())) .log().all(); } + // ===== Helper methods ===== + @NotNull private ValidatableResponse deleteAnnotationSetById(String annotationSetId) { return request - .delete("/api/annotation-sets/" + annotationSetId) + .delete(API_ANNOTATION_SETS + "/" + annotationSetId) .then() .log().all(); } @@ -260,7 +286,7 @@ private ValidatableResponse createAnnotationSet(final UUID annotationSetId, fina final JSONObject annotationSet = createAnnotationSetPayload(annotationSetId, documentId); return request .body(annotationSet.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .statusCode(201) .log().all(); @@ -269,15 +295,13 @@ private ValidatableResponse createAnnotationSet(final UUID annotationSetId, fina @NotNull private JSONObject createAnnotationSetPayload(final UUID annotationSetId, final UUID documentId) { final JSONObject annotationSet = new JSONObject(); - annotationSet.put("documentId", documentId); - annotationSet.put("id", annotationSetId.toString()); + annotationSet.put(FIELD_DOCUMENT_ID, documentId); + annotationSet.put(FIELD_ID, annotationSetId.toString()); final JSONArray annotations = new JSONArray(); final JSONObject annotation = extractJsonObjectFromResponse( - createAnnotation(UUID.randomUUID().toString(), annotationSetId.toString())); + createAnnotation(UUID.randomUUID().toString(), annotationSetId.toString())); annotations.put(0, annotation); - annotationSet.put("annotations", annotations); - - + annotationSet.put(FIELD_ANNOTATIONS, annotations); return annotationSet; } @@ -285,48 +309,46 @@ private JSONObject createAnnotationSetPayload(final UUID annotationSetId, final private ValidatableResponse createAnnotation(String annotationId, String annotationSetId) { final JSONObject annotation = createAnnotationPayload(annotationId, annotationSetId); return request - .body(annotation) - .post("/api/annotations") - .then() - .statusCode(201) - .log().all(); + .body(annotation) + .post(API_ANNOTATIONS) + .then() + .statusCode(201) + .log().all(); } @NotNull private JSONObject createAnnotationPayload(String annotationId, String annotationSetId) { final JSONObject createAnnotations = new JSONObject(); - createAnnotations.put("annotationSetId", annotationSetId); - createAnnotations.put("id", annotationId); - createAnnotations.put("annotationType", "highlight"); - createAnnotations.put("page", 1); - createAnnotations.put("color", "d1d1d1"); + createAnnotations.put(FIELD_ANNOTATION_SET_ID, annotationSetId); + createAnnotations.put(FIELD_ID, annotationId); + createAnnotations.put(FIELD_ANNOTATION_TYPE, VALUE_HIGHLIGHT); + createAnnotations.put(FIELD_PAGE, 1); + createAnnotations.put(FIELD_COLOR, VALUE_COLOR); final JSONArray comments = new JSONArray(); final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("annotationId", annotationId); - comment.put("id", UUID.randomUUID().toString()); + comment.put(FIELD_CONTENT, VALUE_TEXT); + comment.put(FIELD_ANNOTATION_ID, annotationId); + comment.put(FIELD_ID, UUID.randomUUID().toString()); comments.put(0, comment); - createAnnotations.put("comments", comments); + createAnnotations.put(FIELD_COMMENTS, comments); final JSONArray rectangles = new JSONArray(); final JSONObject rectangle = new JSONObject(); - rectangle.put("id", UUID.randomUUID().toString()); - rectangle.put("annotationId", annotationId); + rectangle.put(FIELD_ID, UUID.randomUUID().toString()); + rectangle.put(FIELD_ANNOTATION_ID, annotationId); rectangle.put("x", 0f); rectangle.put("y", 0f); rectangle.put("width", 10f); rectangle.put("height", 11f); rectangles.put(0, rectangle); - createAnnotations.put("rectangles", rectangles); + createAnnotations.put(FIELD_RECTANGLES, rectangles); return createAnnotations; } - @NotNull private JSONObject extractJsonObjectFromResponse(final ValidatableResponse response) { return response.extract().response().as(JSONObject.class); } - } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BaseTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BaseTest.java index 4733e304..4cb3935f 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BaseTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BaseTest.java @@ -23,8 +23,7 @@ @WithTags({@WithTag("testType:Functional")}) public abstract class BaseTest { - @Autowired - protected TestUtil testUtil; + protected final TestUtil testUtil; @Value("${test.url}") protected String testUrl; @@ -35,6 +34,11 @@ public abstract class BaseTest { protected RequestSpecification request; protected RequestSpecification unAuthenticatedRequest; + @Autowired + protected BaseTest(TestUtil testUtil) { + this.testUtil = testUtil; + } + @BeforeEach public void setupRequestSpecification() { request = testUtil diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BookmarkScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BookmarkScenariosTest.java index 605d5015..36ccd1e8 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BookmarkScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/BookmarkScenariosTest.java @@ -6,20 +6,45 @@ import org.json.JSONObject; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.ArrayList; import java.util.List; import java.util.UUID; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.hasItems; -import static org.hamcrest.CoreMatchers.notNullValue; import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.hasItems; +import static org.hamcrest.Matchers.notNullValue; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_BASE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_BOOKMARKS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_BOOKMARKS_MULTIPLE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.BOOKMARKS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.BOOKMARK_NAME; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.CREATED_BY_USER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_COORD; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_PAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_CREATED_BY; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DELETED; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_NAME; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PAGE_NUMBER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PARENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PREVIOUS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_X_COORD; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_Y_COORD; class BookmarkScenariosTest extends BaseTest { private UUID documentId; + @Autowired + public BookmarkScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @BeforeEach public void setup() { documentId = UUID.randomUUID(); @@ -29,18 +54,19 @@ public void setup() { void shouldReturn201WhenCreateNewBookmark() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); + response .statusCode(201) - .body("id", equalTo(bookmarkId.toString())) - .body("documentId", equalTo(documentId.toString())) - .body("name", equalTo("Bookmark for test")) - .body("createdBy", equalTo("user")) - .body("pageNumber", equalTo(1)) - .body("xCoordinate", equalTo(100f)) - .body("yCoordinate", equalTo(100f)) - .body("parent", notNullValue()) - .body("previous", notNullValue()) - .header("Location", equalTo("/api/bookmarks/" + bookmarkId)) + .body(FIELD_ID, equalTo(bookmarkId.toString())) + .body(FIELD_DOCUMENT_ID, equalTo(documentId.toString())) + .body(FIELD_NAME, equalTo(BOOKMARK_NAME)) + .body(FIELD_CREATED_BY, equalTo(CREATED_BY_USER)) + .body(FIELD_PAGE_NUMBER, equalTo(DEFAULT_PAGE)) + .body(FIELD_X_COORD, equalTo(DEFAULT_COORD)) + .body(FIELD_Y_COORD, equalTo(DEFAULT_COORD)) + .body(FIELD_PARENT, notNullValue()) + .body(FIELD_PREVIOUS, notNullValue()) + .header("Location", equalTo(API_BOOKMARKS + "/" + bookmarkId)) .log().all(); } @@ -48,12 +74,11 @@ void shouldReturn201WhenCreateNewBookmark() { void shouldReturn400WhenCreateNewBookmarkWithoutId() { final UUID bookmarkId = UUID.randomUUID(); final JSONObject bookmarkRequestPayload = createBookmarkRequestPayload(bookmarkId); - - bookmarkRequestPayload.remove("id"); + bookmarkRequestPayload.remove(FIELD_ID); request .body(bookmarkRequestPayload.toString()) - .post("/api/bookmarks") + .post(API_BOOKMARKS) .then() .statusCode(400) .log().all(); @@ -66,7 +91,7 @@ void shouldReturn401WhenUnAuthenticatedUserCreateNewBookmark() { unAuthenticatedRequest .body(bookmarkRequestPayload.toString()) - .post("/api/bookmarks") + .post(API_BOOKMARKS) .then() .statusCode(401) .log().all(); @@ -76,11 +101,11 @@ void shouldReturn401WhenUnAuthenticatedUserCreateNewBookmark() { void shouldReturn409WhenCreateNewBookmarkWithoutMandatoryField() { final UUID bookmarkId = UUID.randomUUID(); final JSONObject bookmarkRequestPayload = createBookmarkRequestPayload(bookmarkId); - bookmarkRequestPayload.remove("name"); + bookmarkRequestPayload.remove(FIELD_NAME); request .body(bookmarkRequestPayload.toString()) - .post("/api/bookmarks") + .post(API_BOOKMARKS) .then() .statusCode(409) .log().all(); @@ -90,28 +115,27 @@ void shouldReturn409WhenCreateNewBookmarkWithoutMandatoryField() { void shouldReturn200WhenGetAllBookmarksByDocumentId() { final UUID bookmarkId = UUID.randomUUID(); final JSONObject jsonObject = createBookmarkRequestPayload(bookmarkId); - jsonObject.remove("createdBy"); + jsonObject.remove(FIELD_CREATED_BY); - final ValidatableResponse response = - request.log().all() - .body(jsonObject.toString()) - .post("/api/bookmarks") - .then() - .statusCode(201); + final ValidatableResponse response = request.log().all() + .body(jsonObject.toString()) + .post(API_BOOKMARKS) + .then() + .statusCode(201); final JSONObject newJsonObject = extractJsonObjectFromResponse(response); - final String id = newJsonObject.getString("documentId"); + final String id = newJsonObject.getString(FIELD_DOCUMENT_ID); request - .get(String.format("/api/%s/bookmarks", id)) + .get(String.format(API_BASE + BOOKMARKS, id)) .then() .statusCode(200) - .body("id", equalTo(List.of(bookmarkId.toString()))) - .body("documentId", equalTo(List.of(id))) - .body("name", equalTo(List.of("Bookmark for test"))) - .body("pageNumber", equalTo(List.of(1))) - .body("xCoordinate", equalTo(List.of(100.00f))) - .body("yCoordinate", equalTo(List.of(100.00f))) + .body(FIELD_ID, equalTo(List.of(bookmarkId.toString()))) + .body(FIELD_DOCUMENT_ID, equalTo(List.of(id))) + .body(FIELD_NAME, equalTo(List.of(BOOKMARK_NAME))) + .body(FIELD_PAGE_NUMBER, equalTo(List.of(DEFAULT_PAGE))) + .body(FIELD_X_COORD, equalTo(List.of(DEFAULT_COORD))) + .body(FIELD_Y_COORD, equalTo(List.of(DEFAULT_COORD))) .log().all(); } @@ -122,28 +146,28 @@ void shouldReturn200WhenGetAllBookmarksMoreThan20ByDocumentId() { for (int i = 0; i < 30; i++) { final UUID bookmarkId = UUID.randomUUID(); final JSONObject jsonObject = createBookmarkRequestPayload(bookmarkId); - jsonObject.remove("createdBy"); + jsonObject.remove(FIELD_CREATED_BY); request.log().all() - .body(jsonObject.toString()) - .post("/api/bookmarks") - .then() - .statusCode(201); + .body(jsonObject.toString()) + .post(API_BOOKMARKS) + .then() + .statusCode(201); bookMarks.add(bookmarkId.toString()); } request - .get(String.format("/api/%s/bookmarks", documentId)) + .get(String.format(API_BASE + BOOKMARKS, documentId)) .then() .statusCode(200) - .body("id", containsInAnyOrder(bookMarks.toArray())) + .body(FIELD_ID, containsInAnyOrder(bookMarks.toArray())) .log().all(); } @Test void shouldReturn204WhenResponseBodyIsEmptyForGivenDocId() { request - .get(String.format("/api/%s/bookmarks", UUID.randomUUID())) + .get(String.format(API_BASE + BOOKMARKS, UUID.randomUUID())) .then() .statusCode(204) .log().all(); @@ -152,7 +176,7 @@ void shouldReturn204WhenResponseBodyIsEmptyForGivenDocId() { @Test void shouldReturn401WhenUnAuthenticatedUserGetBookmarksById() { unAuthenticatedRequest - .get(String.format("/api/%s/bookmarks", UUID.randomUUID())) + .get(String.format(API_BASE + BOOKMARKS, UUID.randomUUID())) .then() .statusCode(401) .log().all(); @@ -163,22 +187,22 @@ void shouldReturn200WhenUpdateBookmark() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - jsonObject.put("name", "new name"); + jsonObject.put(FIELD_NAME, "new name"); request .body(jsonObject.toString()) - .put("/api/bookmarks") + .put(API_BOOKMARKS) .then() .statusCode(200) - .body("id", equalTo(bookmarkId.toString())) - .body("documentId", equalTo(documentId.toString())) - .body("name", equalTo("new name")) - .body("createdBy", equalTo("user")) - .body("pageNumber", equalTo(1)) - .body("xCoordinate", equalTo(100f)) - .body("yCoordinate", equalTo(100f)) - .body("parent", notNullValue()) - .body("previous", notNullValue()) + .body(FIELD_ID, equalTo(bookmarkId.toString())) + .body(FIELD_DOCUMENT_ID, equalTo(documentId.toString())) + .body(FIELD_NAME, equalTo("new name")) + .body(FIELD_CREATED_BY, equalTo(CREATED_BY_USER)) + .body(FIELD_PAGE_NUMBER, equalTo(DEFAULT_PAGE)) + .body(FIELD_X_COORD, equalTo(DEFAULT_COORD)) + .body(FIELD_Y_COORD, equalTo(DEFAULT_COORD)) + .body(FIELD_PARENT, notNullValue()) + .body(FIELD_PREVIOUS, notNullValue()) .log().all(); } @@ -187,11 +211,11 @@ void shouldReturn400WhenUpdateBookmarkWithBadRequestPayload() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - jsonObject.remove("id"); + jsonObject.remove(FIELD_ID); request .body(jsonObject.toString()) - .put("/api/bookmarks") + .put(API_BOOKMARKS) .then() .statusCode(400) .log().all(); @@ -205,7 +229,7 @@ void shouldReturn401WhenUnAuthenticatedUserUpdateBookmark() { unAuthenticatedRequest .body(jsonObject.toString()) - .put("/api/bookmarks") + .put(API_BOOKMARKS) .then() .statusCode(401) .log().all(); @@ -216,10 +240,11 @@ void shouldReturn409WhenUpdateBookmarkWithoutMandatoryField() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - jsonObject.remove("name"); + jsonObject.remove(FIELD_NAME); + request .body(jsonObject.toString()) - .put("/api/bookmarks") + .put(API_BOOKMARKS) .then() .statusCode(409) .log().all(); @@ -236,21 +261,19 @@ void shouldReturn200WhenUpdateMultipleBookmarks() { final JSONObject jsonObject2 = extractJsonObjectFromResponse(response2); final JSONArray jsonArray = new JSONArray(); - - jsonObject1.put("name", "new name-1"); + jsonObject1.put(FIELD_NAME, "new name-1"); + jsonObject2.put(FIELD_NAME, "new name-2"); jsonArray.put(jsonObject1); - - jsonObject2.put("name", "new name-2"); jsonArray.put(jsonObject2); request .body(jsonArray.toString()) - .put("/api/bookmarks_multiple") + .put(API_BOOKMARKS_MULTIPLE) .then() .statusCode(200) - .body("documentId", hasItems(documentId.toString())) - .body("id", hasItems(bookmarkId1.toString(), bookmarkId2.toString())) - .body("name", hasItems("new name-1", "new name-2")) + .body(FIELD_DOCUMENT_ID, hasItems(documentId.toString())) + .body(FIELD_ID, hasItems(bookmarkId1.toString(), bookmarkId2.toString())) + .body(FIELD_NAME, hasItems("new name-1", "new name-2")) .log().all(); } @@ -259,13 +282,13 @@ void shouldReturn400WhenUpdateMultipleBookmarksWithBadRequestPayload() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - final JSONArray jsonArray = new JSONArray(); - jsonObject.remove("id"); - jsonArray.put(jsonObject); + jsonObject.remove(FIELD_ID); + + final JSONArray jsonArray = new JSONArray().put(jsonObject); request .body(jsonArray.toString()) - .put("/api/bookmarks_multiple") + .put(API_BOOKMARKS_MULTIPLE) .then() .statusCode(400) .log().all(); @@ -276,12 +299,12 @@ void shouldReturn401WhenUnAuthenticatedUserUpdateMultipleBookmarks() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - final JSONArray jsonArray = new JSONArray(); - jsonArray.put(jsonObject); + + final JSONArray jsonArray = new JSONArray().put(jsonObject); unAuthenticatedRequest .body(jsonArray.toString()) - .put("/api/bookmarks_multiple") + .put(API_BOOKMARKS_MULTIPLE) .then() .statusCode(401) .log().all(); @@ -292,13 +315,13 @@ void shouldReturn409WhenUpdateMultipleBookmarksWithoutMandatoryField() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - jsonObject.remove("name"); - final JSONArray jsonArray = new JSONArray(); - jsonArray.put(jsonObject); + jsonObject.remove(FIELD_NAME); + + final JSONArray jsonArray = new JSONArray().put(jsonObject); request .body(jsonArray.toString()) - .put("/api/bookmarks_multiple") + .put(API_BOOKMARKS_MULTIPLE) .then() .statusCode(409) .log().all(); @@ -309,9 +332,10 @@ void shouldReturn200WhenDeleteBookmarkById() { final UUID bookmarkId = UUID.randomUUID(); final ValidatableResponse response = createBookmark(bookmarkId); final JSONObject jsonObject = extractJsonObjectFromResponse(response); - final String id = jsonObject.getString("id"); + final String id = jsonObject.getString(FIELD_ID); + request - .delete(String.format("/api/bookmarks/%s", id)) + .delete(String.format(API_BOOKMARKS + "/%s", id)) .then() .statusCode(200) .log().all(); @@ -320,7 +344,7 @@ void shouldReturn200WhenDeleteBookmarkById() { @Test void shouldReturn401WhenUnAuthenticatedUserDeleteBookmarkById() { unAuthenticatedRequest - .delete(String.format("/api/bookmarks/%s", UUID.randomUUID())) + .delete(String.format(API_BOOKMARKS + "/%s", UUID.randomUUID())) .then() .statusCode(401) .log().all(); @@ -329,7 +353,7 @@ void shouldReturn401WhenUnAuthenticatedUserDeleteBookmarkById() { @Test void shouldReturn200WhenDeleteBookmarkByNonExistentId() { request - .delete(String.format("/api/bookmarks/%s", UUID.randomUUID())) + .delete(String.format(API_BOOKMARKS + "/%s", UUID.randomUUID())) .then() .statusCode(200) .log().all(); @@ -338,25 +362,21 @@ void shouldReturn200WhenDeleteBookmarkByNonExistentId() { @Test void shouldReturn200WhenDeleteMultipleBookmarks() { final UUID bookmarkId1 = UUID.randomUUID(); - final ValidatableResponse response1 = createBookmark(bookmarkId1); - final JSONObject jsonObject1 = extractJsonObjectFromResponse(response1); + final JSONObject jsonObject1 = extractJsonObjectFromResponse(createBookmark(bookmarkId1)); final UUID bookmarkId2 = UUID.randomUUID(); - final ValidatableResponse response2 = createBookmark(bookmarkId2); - final JSONObject jsonObject2 = extractJsonObjectFromResponse(response2); + final JSONObject jsonObject2 = extractJsonObjectFromResponse(createBookmark(bookmarkId2)); - final JSONObject deleteBookmarkRequest = new JSONObject(); - final JSONArray jsonArray = new JSONArray(); - final Object id1 = jsonObject1.get("id"); - final Object id2 = jsonObject2.get("id"); - jsonArray.put(id1); - jsonArray.put(id2); + final JSONArray jsonArray = new JSONArray() + .put(jsonObject1.get(FIELD_ID)) + .put(jsonObject2.get(FIELD_ID)); - deleteBookmarkRequest.put("deleted", jsonArray); + final JSONObject deleteBookmarkRequest = new JSONObject() + .put(FIELD_DELETED, jsonArray); request .body(deleteBookmarkRequest.toString()) - .delete("/api/bookmarks_multiple") + .delete(API_BOOKMARKS_MULTIPLE) .then() .statusCode(200) .log().all(); @@ -365,14 +385,14 @@ void shouldReturn200WhenDeleteMultipleBookmarks() { @Test void shouldReturn401WhenUnAuthenticatedUserDeleteMultipleBookmarks() { final UUID bookmarkId = UUID.randomUUID(); - final JSONObject deleteBookmarkRequest = new JSONObject(); - final JSONArray jsonArray = new JSONArray(); - jsonArray.put(bookmarkId); - deleteBookmarkRequest.put("deleted", jsonArray); + final JSONArray jsonArray = new JSONArray().put(bookmarkId); + + final JSONObject deleteBookmarkRequest = new JSONObject() + .put(FIELD_DELETED, jsonArray); unAuthenticatedRequest .body(deleteBookmarkRequest.toString()) - .delete("/api/bookmarks_multiple") + .delete(API_BOOKMARKS_MULTIPLE) .then() .statusCode(401) .log().all(); @@ -381,14 +401,14 @@ void shouldReturn401WhenUnAuthenticatedUserDeleteMultipleBookmarks() { @Test void shouldReturn200WhenDeleteMultipleBookmarksWithNonExistentId() { final UUID bookmarkId = UUID.randomUUID(); - final JSONObject deleteBookmarkRequest = new JSONObject(); - final JSONArray jsonArray = new JSONArray(); - jsonArray.put(bookmarkId); - deleteBookmarkRequest.put("deleted", jsonArray); + final JSONArray jsonArray = new JSONArray().put(bookmarkId); + + final JSONObject deleteBookmarkRequest = new JSONObject() + .put(FIELD_DELETED, jsonArray); request .body(deleteBookmarkRequest.toString()) - .delete("/api/bookmarks_multiple") + .delete(API_BOOKMARKS_MULTIPLE) .then() .statusCode(200) .log().all(); @@ -399,24 +419,22 @@ private ValidatableResponse createBookmark(final UUID bookmarkId) { final JSONObject bookmark = createBookmarkRequestPayload(bookmarkId); return request.log().all() .body(bookmark.toString()) - .post("/api/bookmarks") + .post(API_BOOKMARKS) .then() .statusCode(201); } private JSONObject createBookmarkRequestPayload(final UUID bookmarkId) { final JSONObject jsonObject = new JSONObject(); - - jsonObject.put("id", bookmarkId); - jsonObject.put("documentId", documentId); - jsonObject.put("name", "Bookmark for test"); - jsonObject.put("createdBy", "user"); - jsonObject.put("pageNumber", 1); - jsonObject.put("xCoordinate", 100.00); - jsonObject.put("yCoordinate", 100.00); - jsonObject.put("parent", UUID.randomUUID().toString()); - jsonObject.put("previous", UUID.randomUUID().toString()); - + jsonObject.put(FIELD_ID, bookmarkId); + jsonObject.put(FIELD_DOCUMENT_ID, documentId); + jsonObject.put(FIELD_NAME, BOOKMARK_NAME); + jsonObject.put(FIELD_CREATED_BY, CREATED_BY_USER); + jsonObject.put(FIELD_PAGE_NUMBER, DEFAULT_PAGE); + jsonObject.put(FIELD_X_COORD, DEFAULT_COORD); + jsonObject.put(FIELD_Y_COORD, DEFAULT_COORD); + jsonObject.put(FIELD_PARENT, UUID.randomUUID().toString()); + jsonObject.put(FIELD_PREVIOUS, UUID.randomUUID().toString()); return jsonObject; } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/CommentScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/CommentScenariosTest.java index dd934bab..d82ad4d2 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/CommentScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/CommentScenariosTest.java @@ -5,14 +5,38 @@ import org.jetbrains.annotations.NotNull; import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATIONS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_COMMENTS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.COLOR_CODE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_SET_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_TYPE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_COLOR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_PAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.HIGHLIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.LOCATION_HEADER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.NEW_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.UPDATED_CONTENT; class CommentScenariosTest extends BaseTest { + @Autowired + public CommentScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test void shouldReturn201WhenCreateNewComment() { final String newAnnotationSetId = createAnnotationSet(); @@ -22,10 +46,10 @@ void shouldReturn201WhenCreateNewComment() { response .statusCode(201) - .body("id", equalTo(commentId)) - .body("content", equalTo("text")) - .body("annotationId", equalTo(annotationId)) - .header("Location", equalTo("/api/comments/" + commentId)) + .body(FIELD_ID, equalTo(commentId)) + .body(FIELD_CONTENT, equalTo(DEFAULT_CONTENT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) + .header(LOCATION_HEADER, equalTo(API_COMMENTS + "/" + commentId)) .log().all(); } @@ -33,12 +57,12 @@ void shouldReturn201WhenCreateNewComment() { void shouldReturn400WhenCreateNewCommentWithoutId() { final String annotationId = UUID.randomUUID().toString(); final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("annotationId", annotationId); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ANNOTATION_ID, annotationId); request .body(comment.toString()) - .post("/api/comments") + .post(API_COMMENTS) .then() .statusCode(400) .log().all(); @@ -48,12 +72,12 @@ void shouldReturn400WhenCreateNewCommentWithoutId() { void shouldReturn400WhenCreateNewCommentWithoutAnnotationId() { final String commentId = UUID.randomUUID().toString(); final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("id", commentId); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ID, commentId); request .body(comment.toString()) - .post("/api/comments") + .post(API_COMMENTS) .then() .statusCode(400) .log().all(); @@ -68,7 +92,7 @@ void shouldReturn401WhenUnAuthenticatedUserCreateNewComment() { unAuthenticatedRequest .body(comment.toString()) - .post("/api/comments") + .post(API_COMMENTS) .then() .statusCode(401) .log().all(); @@ -79,9 +103,10 @@ void shouldReturn500WhenCreateNewCommentWithNonExistentAnnotationId() { final String nonExistentAnnotationId = UUID.randomUUID().toString(); final String commentId = UUID.randomUUID().toString(); final JSONObject comment = createCommentPayload(nonExistentAnnotationId, commentId); + request .body(comment.toString()) - .post("/api/comments") + .post(API_COMMENTS) .then() .statusCode(500) .log().all(); @@ -93,15 +118,15 @@ void shouldReturn200WhenGetCommentById() { final String annotationId = createAnnotation(newAnnotationSetId); final String commentId = UUID.randomUUID().toString(); final ValidatableResponse response = createComment(annotationId, commentId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); request - .get("/api/comments/" + id) + .get(API_COMMENTS + "/" + id) .then() .statusCode(200) - .body("id", equalTo(commentId)) - .body("content", equalTo("text")) - .body("annotationId", equalTo(annotationId)) + .body(FIELD_ID, equalTo(commentId)) + .body(FIELD_CONTENT, equalTo(DEFAULT_CONTENT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } @@ -109,7 +134,7 @@ void shouldReturn200WhenGetCommentById() { void shouldReturn404WhenGetCommentNotFoundById() { final String commentId = UUID.randomUUID().toString(); request - .get("/api/comments/" + commentId) + .get(API_COMMENTS + "/" + commentId) .then() .statusCode(404) .log().all(); @@ -119,7 +144,7 @@ void shouldReturn404WhenGetCommentNotFoundById() { void shouldReturn401WhenUnAuthenticatedUserGetCommentById() { final String commentId = UUID.randomUUID().toString(); unAuthenticatedRequest - .get("/api/comments/" + commentId) + .get(API_COMMENTS + "/" + commentId) .then() .statusCode(401) .log().all(); @@ -131,22 +156,21 @@ void shouldReturn200WhenGetAllComments() { final String annotationId = createAnnotation(newAnnotationSetId); final String commentId = UUID.randomUUID().toString(); final ValidatableResponse response = createComment(annotationId, commentId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); assertNotNull(id); request - .get("/api/comments") + .get(API_COMMENTS) .then() .statusCode(200) .body("size()", Matchers.greaterThanOrEqualTo(1)) .log().all(); } - @Test void shouldReturn401WhenUnAuthenticatedUserGetAllComments() { unAuthenticatedRequest - .get("/api/comments") + .get(API_COMMENTS) .then() .statusCode(401) .log().all(); @@ -159,16 +183,16 @@ void shouldReturn200WhenUpdateComment() { final String commentId = UUID.randomUUID().toString(); final ValidatableResponse response = createComment(annotationId, commentId); final JSONObject comment = extractJsonObjectFromResponse(response); - comment.put("content", "updated text"); + comment.put(FIELD_CONTENT, UPDATED_CONTENT); request .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(200) - .body("id", equalTo(commentId)) - .body("content", equalTo("updated text")) - .body("annotationId", equalTo(annotationId)) + .body(FIELD_ID, equalTo(commentId)) + .body(FIELD_CONTENT, equalTo(UPDATED_CONTENT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } @@ -177,9 +201,10 @@ void shouldReturn500WhenUpdateCommentWithNonExistentAnnotationId() { final String commentId = UUID.randomUUID().toString(); final String nonExistentAnnotationId = UUID.randomUUID().toString(); final JSONObject comment = createCommentPayload(nonExistentAnnotationId, commentId); + request .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(500) .log().all(); @@ -188,12 +213,12 @@ void shouldReturn500WhenUpdateCommentWithNonExistentAnnotationId() { @Test void shouldReturn400WhenUpdateCommentWithoutId() { final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("annotationId", UUID.randomUUID()); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ANNOTATION_ID, UUID.randomUUID()); request .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(400) .log().all(); @@ -202,12 +227,12 @@ void shouldReturn400WhenUpdateCommentWithoutId() { @Test void shouldReturn400WhenUpdateCommentWithoutAnnotationId() { final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("id", UUID.randomUUID()); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ID, UUID.randomUUID()); request .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(400) .log().all(); @@ -216,12 +241,12 @@ void shouldReturn400WhenUpdateCommentWithoutAnnotationId() { @Test void shouldReturn401WhenUnAuthenticatedUserUpdateComment() { final JSONObject comment = new JSONObject(); - comment.put("content", "text"); - comment.put("annotationId", UUID.randomUUID()); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ANNOTATION_ID, UUID.randomUUID()); unAuthenticatedRequest .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(401) .log().all(); @@ -233,7 +258,7 @@ void shouldReturn200WhenDeleteCommentById() { final String annotationId = createAnnotation(newAnnotationSetId); final String commentId = UUID.randomUUID().toString(); final ValidatableResponse response = createComment(annotationId, commentId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); final ValidatableResponse deletedResponse = deleteCommentById(id); deletedResponse.statusCode(200); @@ -250,7 +275,7 @@ void shouldReturn200WhenDeleteCommentByNonExistentId() { @Test void shouldReturn401WhenUnAuthenticatedUserDeleteComment() { unAuthenticatedRequest - .delete("/api/comments/" + UUID.randomUUID()) + .delete(API_COMMENTS + "/" + UUID.randomUUID()) .then() .statusCode(401) .log().all(); @@ -263,24 +288,24 @@ void shouldReturn200WhenTryToUpdateCommentAfterItHasBeenDeleted() { final String commentId = UUID.randomUUID().toString(); final ValidatableResponse response = createComment(annotationId, commentId); final JSONObject comment = extractJsonObjectFromResponse(response); - final String id = comment.getString("id"); + final String id = comment.getString(FIELD_ID); deleteCommentById(id).statusCode(200); - comment.put("content", "new text"); + comment.put(FIELD_CONTENT, NEW_CONTENT); request .body(comment.toString()) - .put("/api/comments") + .put(API_COMMENTS) .then() .statusCode(200) - .body("id", equalTo(id)) - .body("content", equalTo("new text")) - .body("annotationId", equalTo(annotationId)) + .body(FIELD_ID, equalTo(id)) + .body(FIELD_CONTENT, equalTo(NEW_CONTENT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } private ValidatableResponse deleteCommentById(String commentId) { return request - .delete("/api/comments/" + commentId) + .delete(API_COMMENTS + "/" + commentId) .then() .log().all(); } @@ -288,10 +313,9 @@ private ValidatableResponse deleteCommentById(String commentId) { @NotNull private ValidatableResponse createComment(String annotationId, String commentId) { final JSONObject comment = createCommentPayload(annotationId, commentId); - return request.log().all() .body(comment.toString()) - .post("/api/comments") + .post(API_COMMENTS) .then() .statusCode(201); } @@ -300,51 +324,51 @@ private ValidatableResponse createComment(String annotationId, String commentId) private String createAnnotation(String newAnnotationSetId) { final UUID annotationId = UUID.randomUUID(); final JSONObject createAnnotations = new JSONObject(); - createAnnotations.put("annotationSetId", newAnnotationSetId); - createAnnotations.put("id", annotationId); - createAnnotations.put("annotationType", "highlight"); - createAnnotations.put("page", 1); - createAnnotations.put("color", "d1d1d1"); + createAnnotations.put(FIELD_ANNOTATION_SET_ID, newAnnotationSetId); + createAnnotations.put(FIELD_ID, annotationId); + createAnnotations.put(FIELD_ANNOTATION_TYPE, HIGHLIGHT); + createAnnotations.put(FIELD_PAGE, 1); + createAnnotations.put(FIELD_COLOR, COLOR_CODE); return request .body(createAnnotations) - .post("/api/annotations") + .post(API_ANNOTATIONS) .then() .statusCode(201) - .body("id", equalTo(annotationId.toString())) + .body(FIELD_ID, equalTo(annotationId.toString())) .extract() .response() .getBody() .jsonPath() - .get("id"); + .get(FIELD_ID); } @NotNull private String createAnnotationSet() { final JSONObject jsonObject = new JSONObject(); final UUID newAnnotationSetId = UUID.randomUUID(); - jsonObject.put("documentId", UUID.randomUUID().toString()); - jsonObject.put("id", newAnnotationSetId.toString()); + jsonObject.put(FIELD_DOCUMENT_ID, UUID.randomUUID().toString()); + jsonObject.put(FIELD_ID, newAnnotationSetId.toString()); return request .body(jsonObject.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .statusCode(201) - .body("id", equalTo(newAnnotationSetId.toString())) + .body(FIELD_ID, equalTo(newAnnotationSetId.toString())) .extract() .response() .getBody() .jsonPath() - .get("id"); + .get(FIELD_ID); } @NotNull private JSONObject createCommentPayload(String annotationId, String commentId) { final JSONObject comment = new JSONObject(); - comment.put("id", commentId); - comment.put("content", "text"); - comment.put("annotationId", annotationId); + comment.put(FIELD_ID, commentId); + comment.put(FIELD_CONTENT, DEFAULT_CONTENT); + comment.put(FIELD_ANNOTATION_ID, annotationId); return comment; } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/FilterAnnotationSetScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/FilterAnnotationSetScenariosTest.java index db73b1f7..8219b2a4 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/FilterAnnotationSetScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/FilterAnnotationSetScenariosTest.java @@ -2,20 +2,31 @@ import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_FILTER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; class FilterAnnotationSetScenariosTest extends BaseTest { + @Autowired + public FilterAnnotationSetScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test void shouldReturn404WhenFilterAnnotationSetWithNonExistentDocumentId() { final UUID documentId = UUID.randomUUID(); request - .param("documentId", documentId) - .get("/api/annotation-sets/filter") + .param(FIELD_DOCUMENT_ID, documentId) + .get(API_FILTER) .then() .assertThat() .statusCode(204) @@ -29,13 +40,13 @@ void shouldReturn200WhenFilterAnnotationSetWithDocumentId() { createAnnotationSet(annotationSetId, documentId); request - .param("documentId", documentId) - .get("/api/annotation-sets/filter") + .param(FIELD_DOCUMENT_ID, documentId) + .get(API_FILTER) .then() .assertThat() .statusCode(200) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", equalTo(documentId.toString())) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, equalTo(documentId.toString())) .log().all(); } @@ -46,8 +57,8 @@ void shouldReturn401WhenUnAuthenticatedUserFilterAnnotationSetWithDocumentId() { createAnnotationSet(annotationSetId, documentId); unAuthenticatedRequest - .param("documentId", documentId) - .get("/api/annotation-sets/filter") + .param(FIELD_DOCUMENT_ID, documentId) + .get(API_FILTER) .then() .assertThat() .statusCode(401) @@ -58,21 +69,20 @@ private void createAnnotationSet(final UUID annotationSetId, final UUID document final JSONObject annotationSet = createAnnotationSetPayload(annotationSetId, documentId); request .body(annotationSet.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() .assertThat() .statusCode(201) - .body("id", equalTo(annotationSetId.toString())) - .body("documentId", equalTo(documentId.toString())) - .header("Location", equalTo("/api/annotation-sets/" + annotationSetId)) + .body(FIELD_ID, equalTo(annotationSetId.toString())) + .body(FIELD_DOCUMENT_ID, equalTo(documentId.toString())) + .header("Location", equalTo(API_ANNOTATION_SETS + "/" + annotationSetId)) .log().all(); } private JSONObject createAnnotationSetPayload(final UUID annotationSetId, final UUID documentId) { final JSONObject annotationSet = new JSONObject(); - annotationSet.put("documentId", documentId); - annotationSet.put("id", annotationSetId.toString()); - + annotationSet.put(FIELD_DOCUMENT_ID, documentId); + annotationSet.put(FIELD_ID, annotationSetId.toString()); return annotationSet; } } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/MetadataScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/MetadataScenariosTest.java index 5df36f9b..69c36b41 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/MetadataScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/MetadataScenariosTest.java @@ -7,80 +7,94 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.context.properties.EnableConfigurationProperties; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import uk.gov.hmcts.reform.em.annotation.testutil.ToggleProperties; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.jupiter.api.Assumptions.assumeTrue; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_METADATA; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_ROTATION_ANGLE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_DOCUMENT_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ERRORS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ROTATION_ANGLE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.HEADER_LOCATION; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.MESSAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_BAD_REQUEST; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_CREATED; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_NO_CONTENT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_OK; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_UNAUTHORIZED; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.VALIDATION_NOT_NULL; @EnableConfigurationProperties(ToggleProperties.class) class MetadataScenariosTest extends BaseTest { + private final ToggleProperties toggleProperties; + @Autowired - ToggleProperties toggleProperties; + public MetadataScenariosTest(TestUtil testUtil, ToggleProperties toggleProperties) { + super(testUtil); + this.toggleProperties = toggleProperties; + } @Test void shouldReturn201WhenCreateNewMetadata() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); final ValidatableResponse response = createMetadata(documentId); response - .statusCode(201) - .body("rotationAngle", equalTo(90)) - .body("documentId", equalTo(documentId)) - .header("Location", equalTo("/api/metadata/" + documentId)) + .statusCode(STATUS_CREATED) + .body(FIELD_ROTATION_ANGLE, equalTo(DEFAULT_ROTATION_ANGLE)) + .body(FIELD_DOCUMENT_ID, equalTo(documentId)) + .header(HEADER_LOCATION, equalTo(API_METADATA + documentId)) .log().all(); } @Test void shouldReturn400WhenCreateNewMetadataWithoutDocumentId() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); final JSONObject metadataPayload = createMetadataPayload(documentId); - - metadataPayload.remove("documentId"); + metadataPayload.remove(FIELD_DOCUMENT_ID); request .body(metadataPayload.toString()) - .post("/api/metadata/") + .post(API_METADATA) .then() - .statusCode(400) - .body("fieldErrors", Matchers.hasSize(1)) - .body("fieldErrors[0].field", equalTo("documentId")) - .body("fieldErrors[0].message", equalTo("NotNull")) + .statusCode(STATUS_BAD_REQUEST) + .body(FIELD_ERRORS, Matchers.hasSize(1)) + .body(FIELD_ERRORS + "[0]." + FIELD, equalTo(FIELD_DOCUMENT_ID)) + .body(FIELD_ERRORS + "[0]." + MESSAGE, equalTo(VALIDATION_NOT_NULL)) .log().all(); } @Test void shouldReturn400WhenCreateNewMetadataWithoutRotationAngle() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); final JSONObject metadataPayload = createMetadataPayload(documentId); - - metadataPayload.remove("rotationAngle"); + metadataPayload.remove(FIELD_ROTATION_ANGLE); request .body(metadataPayload.toString()) - .post("/api/metadata/") + .post(API_METADATA) .then() - .statusCode(400) - .body("fieldErrors", Matchers.hasSize(1)) - .body("fieldErrors[0].field", equalTo("rotationAngle")) - .body("fieldErrors[0].message", equalTo("NotNull")) + .statusCode(STATUS_BAD_REQUEST) + .body(FIELD_ERRORS, Matchers.hasSize(1)) + .body(FIELD_ERRORS + "[0]." + FIELD, equalTo(FIELD_ROTATION_ANGLE)) + .body(FIELD_ERRORS + "[0]." + MESSAGE, equalTo(VALIDATION_NOT_NULL)) .log().all(); } @Test void shouldReturn401WhenUnAuthenticatedUserCreateNewMetadata() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); @@ -88,63 +102,60 @@ void shouldReturn401WhenUnAuthenticatedUserCreateNewMetadata() { unAuthenticatedRequest .body(metadataPayload) - .post("/api/metadata/") + .post(API_METADATA) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @Test void shouldReturn200WhenGetMetadataByDocumentId() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); createMetadata(documentId); request - .get("/api/metadata/" + documentId) + .get(API_METADATA + documentId) .then() - .statusCode(200) - .body("rotationAngle", equalTo(90)) - .body("documentId", equalTo(documentId)) + .statusCode(STATUS_OK) + .body(FIELD_ROTATION_ANGLE, equalTo(DEFAULT_ROTATION_ANGLE)) + .body(FIELD_DOCUMENT_ID, equalTo(documentId)) .log().all(); } @Test void shouldReturn204WhenGetMetadataByNonExistentDocumentId() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); request - .get("/api/metadata/" + documentId) + .get(API_METADATA + documentId) .then() - .statusCode(204) + .statusCode(STATUS_NO_CONTENT) .log().all(); } @Test void shouldReturn401WhenUnAuthenticatedUserGetMetadataByDocumentId() { - // If the Endpoint Toggles are enabled, continue, if not skip and ignore assumeTrue(toggleProperties.isEnableMetadataEndpoint()); final String documentId = UUID.randomUUID().toString(); createMetadata(documentId); unAuthenticatedRequest - .get("/api/metadata/" + documentId) + .get(API_METADATA + documentId) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } - public JSONObject createMetadataPayload(final String documentId) { + @NotNull + private JSONObject createMetadataPayload(final String documentId) { final JSONObject jsonObject = new JSONObject(); - jsonObject.put("rotationAngle", 90); - jsonObject.put("documentId", documentId); - + jsonObject.put(FIELD_ROTATION_ANGLE, DEFAULT_ROTATION_ANGLE); + jsonObject.put(FIELD_DOCUMENT_ID, documentId); return jsonObject; } @@ -154,9 +165,9 @@ private ValidatableResponse createMetadata(final String documentId) { return request .body(metadata.toString()) - .post("/api/metadata/") + .post(API_METADATA) .then() - .statusCode(201) + .statusCode(STATUS_CREATED) .log().all(); } } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/OpenIdConnectScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/OpenIdConnectScenariosTest.java index ed059404..bb264e52 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/OpenIdConnectScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/OpenIdConnectScenariosTest.java @@ -1,60 +1,65 @@ package uk.gov.hmcts.reform.em.annotation.functional; import org.junit.jupiter.api.Test; -import org.springframework.http.MediaType; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; + +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.CONTENT_TYPE_JSON; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_UNAUTHORIZED; class OpenIdConnectScenariosTest extends BaseTest { + @Autowired + public OpenIdConnectScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test - // Invalid IdamAuth void testWithInvalidIdamAuth() { + // Invalid IdamAuth testUtil - .invalidIdamAuthrequest() - .baseUri(testUrl) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .get("/api/annotation-sets") - .then() - .statusCode(401); + .invalidIdamAuthrequest() + .baseUri(testUrl) + .contentType(CONTENT_TYPE_JSON) + .get(API_ANNOTATION_SETS) + .then() + .statusCode(STATUS_UNAUTHORIZED); } @Test - // Empty S2SAuth void testWithEmptyS2SAuth() { - + // Empty S2SAuth testUtil - .validAuthRequestWithEmptyS2SAuth() - .baseUri(testUrl) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .get("/api/annotation-sets") - .then() - .statusCode(401); + .validAuthRequestWithEmptyS2SAuth() + .baseUri(testUrl) + .contentType(CONTENT_TYPE_JSON) + .get(API_ANNOTATION_SETS) + .then() + .statusCode(STATUS_UNAUTHORIZED); } @Test - // Empty IdamAuth and Valid S2S Auth void testWithEmptyIdamAuthAndValidS2SAuth() { - + // Empty IdamAuth and Valid S2S Auth testUtil - .validS2SAuthWithEmptyIdamAuth() - .baseUri(testUrl) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .get("/api/annotation-sets") - .then() - .statusCode(401); - + .validS2SAuthWithEmptyIdamAuth() + .baseUri(testUrl) + .contentType(CONTENT_TYPE_JSON) + .get(API_ANNOTATION_SETS) + .then() + .statusCode(STATUS_UNAUTHORIZED); } @Test - // Empty IdamAuth and Empty S2SAuth void testIdamAuthAndS2SAuthAreEmpty() { - + // Empty IdamAuth and Empty S2SAuth testUtil - .emptyIdamAuthAndEmptyS2SAuth() - .baseUri(testUrl) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .get("/api/annotation-sets") - .then() - .statusCode(401); + .emptyIdamAuthAndEmptyS2SAuth() + .baseUri(testUrl) + .contentType(CONTENT_TYPE_JSON) + .get(API_ANNOTATION_SETS) + .then() + .statusCode(STATUS_UNAUTHORIZED); } - } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/RectangleScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/RectangleScenariosTest.java index 07b38d38..2f1dfc87 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/RectangleScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/RectangleScenariosTest.java @@ -5,13 +5,45 @@ import org.jetbrains.annotations.NotNull; import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; import static org.hamcrest.CoreMatchers.equalTo; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATIONS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_ANNOTATION_SETS; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_RECTANGLES; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.API_RECTANGLES_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_ANNOTATION_TYPE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_COLOR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_HEIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_PAGE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_WIDTH; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_X; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.DEFAULT_Y; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ANNOTATION_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_HEIGHT; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_ID; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_WIDTH; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_X; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.FIELD_Y; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.HEADER_LOCATION_TEMPLATE; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.LOCATION_HEADER; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_BAD_REQUEST; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_CREATED; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_INTERNAL_SERVER_ERROR; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_NOT_FOUND; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_OK; +import static uk.gov.hmcts.reform.em.annotation.functional.TestConsts.STATUS_UNAUTHORIZED; class RectangleScenariosTest extends BaseTest { + @Autowired + public RectangleScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test void shouldReturn201WhenCreateNewRectangle() { final String newAnnotationSetId = createAnnotationSet(); @@ -21,13 +53,13 @@ void shouldReturn201WhenCreateNewRectangle() { final ValidatableResponse response = createRectangle(annotationId, rectangleId); response - .statusCode(201) - .body("x", equalTo(1f)) - .body("y", equalTo(2f)) - .body("width", equalTo(10f)) - .body("height", equalTo(11f)) - .body("annotationId", equalTo(annotationId)) - .header("Location", equalTo("/api/rectangles/" + rectangleId)) + .statusCode(STATUS_CREATED) + .body(FIELD_X, equalTo(DEFAULT_X)) + .body(FIELD_Y, equalTo(DEFAULT_Y)) + .body(FIELD_WIDTH, equalTo(DEFAULT_WIDTH)) + .body(FIELD_HEIGHT, equalTo(DEFAULT_HEIGHT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) + .header(LOCATION_HEADER, equalTo(HEADER_LOCATION_TEMPLATE + rectangleId)) .log().all(); } @@ -35,84 +67,78 @@ void shouldReturn201WhenCreateNewRectangle() { void shouldReturn400WhenCreateNewRectangleWithoutId() { final String newAnnotationSetId = createAnnotationSet(); final String annotationId = createAnnotation(newAnnotationSetId); - final String rectangleId = UUID.randomUUID().toString(); - final JSONObject rectanglePayload = createRectanglePayload(annotationId, rectangleId); + final JSONObject rectanglePayload = createRectanglePayload(annotationId, UUID.randomUUID().toString()); - rectanglePayload.remove("id"); + rectanglePayload.remove(FIELD_ID); request .body(rectanglePayload.toString()) - .post("/api/rectangles") + .post(API_RECTANGLES) .then() - .statusCode(400) + .statusCode(STATUS_BAD_REQUEST) .log().all(); } @Test void shouldReturn401WhenUnAuthenticatedUserCreateNewRectangle() { final String annotationId = UUID.randomUUID().toString(); - final String rectangleId = UUID.randomUUID().toString(); - final JSONObject rectanglePayload = createRectanglePayload(annotationId, rectangleId); + final JSONObject rectanglePayload = createRectanglePayload(annotationId, UUID.randomUUID().toString()); unAuthenticatedRequest .body(rectanglePayload.toString()) - .post("/api/rectangles") + .post(API_RECTANGLES) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @Test void shouldReturn404WhenCreateNewRectangleWithNonExistentAnnotationId() { + final JSONObject rectanglePayload = + createRectanglePayload(UUID.randomUUID().toString(), UUID.randomUUID().toString()); - final String nonExistentAnnotationId = UUID.randomUUID().toString(); - final String rectangleId = UUID.randomUUID().toString(); - final JSONObject rectanglePayload = createRectanglePayload(nonExistentAnnotationId, rectangleId); request - .body(rectanglePayload.toString()) - .post("/api/rectangles") - .then() - .statusCode(404) - .log().all(); + .body(rectanglePayload.toString()) + .post(API_RECTANGLES) + .then() + .statusCode(STATUS_NOT_FOUND) + .log().all(); } @Test void shouldReturn200WhenGetRectangleById() { final String newAnnotationSetId = createAnnotationSet(); final String annotationId = createAnnotation(newAnnotationSetId); - final String rectangleId = UUID.randomUUID().toString(); - final ValidatableResponse response = createRectangle(annotationId, rectangleId); - final String id = extractJsonObjectFromResponse(response).getString("id"); + final ValidatableResponse response = createRectangle(annotationId, UUID.randomUUID().toString()); + final String id = extractJsonObjectFromResponse(response).getString(FIELD_ID); request - .get("/api/rectangles/" + id) + .get(API_RECTANGLES_ID + id) .then() - .statusCode(200) - .body("x", equalTo(1f)) - .body("y", equalTo(2f)) - .body("width", equalTo(10f)) - .body("height", equalTo(11f)) - .body("annotationId", equalTo(annotationId)) + .statusCode(STATUS_OK) + .body(FIELD_X, equalTo(DEFAULT_X)) + .body(FIELD_Y, equalTo(DEFAULT_Y)) + .body(FIELD_WIDTH, equalTo(DEFAULT_WIDTH)) + .body(FIELD_HEIGHT, equalTo(DEFAULT_HEIGHT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } @Test void shouldReturn404WhenGetRectangleNotFoundById() { - final String rectangleId = UUID.randomUUID().toString(); request - .get("/api/rectangles/" + rectangleId) + .get(API_RECTANGLES_ID + UUID.randomUUID()) .then() - .statusCode(404) + .statusCode(STATUS_NOT_FOUND) .log().all(); } @Test void shouldReturn401WhenUnAuthenticatedUserGetRectangleById() { - final String rectangleId = UUID.randomUUID().toString(); unAuthenticatedRequest - .get("/api/rectangles/" + rectangleId) + .get(API_RECTANGLES_ID + UUID.randomUUID()) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @@ -120,13 +146,12 @@ void shouldReturn401WhenUnAuthenticatedUserGetRectangleById() { void shouldReturn200WhenGetAllRectangles() { final String newAnnotationSetId = createAnnotationSet(); final String annotationId = createAnnotation(newAnnotationSetId); - final String rectangleId = UUID.randomUUID().toString(); - createRectangle(annotationId, rectangleId); + createRectangle(annotationId, UUID.randomUUID().toString()); request - .get("/api/rectangles") + .get(API_RECTANGLES) .then() - .statusCode(200) + .statusCode(STATUS_OK) .body("size()", Matchers.greaterThanOrEqualTo(1)) .log().all(); } @@ -134,9 +159,9 @@ void shouldReturn200WhenGetAllRectangles() { @Test void shouldReturn401WhenUnAuthenticatedUserGetAllRectangles() { unAuthenticatedRequest - .get("/api/rectangles") + .get(API_RECTANGLES) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @@ -147,64 +172,60 @@ void shouldReturn200WhenUpdateRectangle() { final String rectangleId = UUID.randomUUID().toString(); final ValidatableResponse response = createRectangle(annotationId, rectangleId); final JSONObject rectangle = extractJsonObjectFromResponse(response); - rectangle.put("x", 3f); - rectangle.put("y", 4f); + rectangle.put(FIELD_X, 3f); + rectangle.put(FIELD_Y, 4f); request .body(rectangle.toString()) - .put("/api/rectangles") + .put(API_RECTANGLES) .then() - .statusCode(200) - .body("id", equalTo(rectangleId)) - .body("x", equalTo(3f)) - .body("y", equalTo(4f)) - .body("width", equalTo(10f)) - .body("height", equalTo(11f)) - .body("annotationId", equalTo(annotationId)) + .statusCode(STATUS_OK) + .body(FIELD_ID, equalTo(rectangleId)) + .body(FIELD_X, equalTo(3f)) + .body(FIELD_Y, equalTo(4f)) + .body(FIELD_WIDTH, equalTo(DEFAULT_WIDTH)) + .body(FIELD_HEIGHT, equalTo(DEFAULT_HEIGHT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } @Test void shouldReturn500WhenUpdateRectangleWithNonExistentAnnotationId() { - final String rectangleId = UUID.randomUUID().toString(); - final String nonExistentAnnotationId = UUID.randomUUID().toString(); - final JSONObject rectangle = createRectanglePayload(nonExistentAnnotationId, rectangleId); + final JSONObject rectangle = + createRectanglePayload(UUID.randomUUID().toString(), UUID.randomUUID().toString()); + request .body(rectangle.toString()) - .put("/api/rectangles") + .put(API_RECTANGLES) .then() - .statusCode(500) + .statusCode(STATUS_INTERNAL_SERVER_ERROR) .log().all(); } @Test void shouldReturn400WhenUpdateRectangleWithoutId() { - final String newAnnotationSetId = createAnnotationSet(); - final String annotationId = createAnnotation(newAnnotationSetId); - final String rectangleId = UUID.randomUUID().toString(); - final JSONObject rectangle = createRectanglePayload(annotationId, rectangleId); - - rectangle.remove("id"); + final JSONObject rectangle = + createRectanglePayload(createAnnotation(createAnnotationSet()), UUID.randomUUID().toString()); + rectangle.remove(FIELD_ID); request .body(rectangle.toString()) - .put("/api/rectangles") + .put(API_RECTANGLES) .then() - .statusCode(400) + .statusCode(STATUS_BAD_REQUEST) .log().all(); } @Test void shouldReturn401WhenUnAuthenticatedUserUpdateRectangle() { - final String annotationId = UUID.randomUUID().toString(); - final String rectangleId = UUID.randomUUID().toString(); - final JSONObject rectangle = createRectanglePayload(annotationId, rectangleId); + final JSONObject rectangle = + createRectanglePayload(UUID.randomUUID().toString(), UUID.randomUUID().toString()); unAuthenticatedRequest .body(rectangle.toString()) - .put("/api/rectangles") + .put(API_RECTANGLES) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @@ -212,29 +233,23 @@ void shouldReturn401WhenUnAuthenticatedUserUpdateRectangle() { void shouldReturn200WhenDeleteRectangleById() { final String newAnnotationSetId = createAnnotationSet(); final String annotationId = createAnnotation(newAnnotationSetId); - final String rectangleId = UUID.randomUUID().toString(); - final ValidatableResponse createdResponse = createRectangle(annotationId, rectangleId); - final String id = extractJsonObjectFromResponse(createdResponse).getString("id"); + final ValidatableResponse createdResponse = createRectangle(annotationId, UUID.randomUUID().toString()); + final String id = extractJsonObjectFromResponse(createdResponse).getString(FIELD_ID); - final ValidatableResponse deletedResponse = deleteRectangleById(id); - - deletedResponse.statusCode(200); + deleteRectangleById(id).statusCode(STATUS_OK); } @Test void shouldReturn200WhenDeleteRectangleByNonExistentId() { - final String nonExistentRectangleId = UUID.randomUUID().toString(); - final ValidatableResponse deletedResponse = deleteRectangleById(nonExistentRectangleId); - - deletedResponse.statusCode(200); + deleteRectangleById(UUID.randomUUID().toString()).statusCode(STATUS_OK); } @Test void shouldReturn401WhenUnAuthenticatedUserDeleteRectangle() { unAuthenticatedRequest - .delete("/api/rectangles/" + UUID.randomUUID()) + .delete(API_RECTANGLES_ID + UUID.randomUUID()) .then() - .statusCode(401) + .statusCode(STATUS_UNAUTHORIZED) .log().all(); } @@ -245,29 +260,30 @@ void shouldReturn200WhenUpdateRectangleAfterItHasBeenDeleted() { final String rectangleId = UUID.randomUUID().toString(); final ValidatableResponse response = createRectangle(annotationId, rectangleId); final JSONObject rectangle = extractJsonObjectFromResponse(response); - final String id = rectangle.getString("id"); - deleteRectangleById(id).statusCode(200); - rectangle.put("x", 3f); - rectangle.put("y", 4f); + final String id = rectangle.getString(FIELD_ID); + + deleteRectangleById(id).statusCode(STATUS_OK); + rectangle.put(FIELD_X, 3f); + rectangle.put(FIELD_Y, 4f); request .body(rectangle.toString()) - .put("/api/rectangles") + .put(API_RECTANGLES) .then() - .statusCode(200) - .body("id", equalTo(rectangleId)) - .body("x", equalTo(3f)) - .body("y", equalTo(4f)) - .body("width", equalTo(10f)) - .body("height", equalTo(11f)) - .body("annotationId", equalTo(annotationId)) + .statusCode(STATUS_OK) + .body(FIELD_ID, equalTo(rectangleId)) + .body(FIELD_X, equalTo(3f)) + .body(FIELD_Y, equalTo(4f)) + .body(FIELD_WIDTH, equalTo(DEFAULT_WIDTH)) + .body(FIELD_HEIGHT, equalTo(DEFAULT_HEIGHT)) + .body(FIELD_ANNOTATION_ID, equalTo(annotationId)) .log().all(); } @NotNull private ValidatableResponse deleteRectangleById(String rectangleId) { return request - .delete("/api/rectangles/" + rectangleId) + .delete(API_RECTANGLES_ID + rectangleId) .then() .log().all(); } @@ -277,32 +293,32 @@ private ValidatableResponse createRectangle(String annotationId, String rectangl final JSONObject rectangle = createRectanglePayload(annotationId, rectangleId); return request.log().all() .body(rectangle.toString()) - .post("/api/rectangles") + .post(API_RECTANGLES) .then() - .statusCode(201); + .statusCode(STATUS_CREATED); } @NotNull private String createAnnotation(final String newAnnotationSetId) { final UUID annotationId = UUID.randomUUID(); - final JSONObject createAnnotations = new JSONObject(); - createAnnotations.put("annotationSetId", newAnnotationSetId); - createAnnotations.put("id", annotationId); - createAnnotations.put("annotationType", "highlight"); - createAnnotations.put("page", 1); - createAnnotations.put("color", "d1d1d1"); + final JSONObject annotation = new JSONObject(); + annotation.put("annotationSetId", newAnnotationSetId); + annotation.put(FIELD_ID, annotationId); + annotation.put("annotationType", DEFAULT_ANNOTATION_TYPE); + annotation.put("page", DEFAULT_PAGE); + annotation.put("color", DEFAULT_COLOR); return request - .body(createAnnotations) - .post("/api/annotations") + .body(annotation) + .post(API_ANNOTATIONS) .then() - .statusCode(201) - .body("id", equalTo(annotationId.toString())) + .statusCode(STATUS_CREATED) + .body(FIELD_ID, equalTo(annotationId.toString())) .extract() .response() .getBody() .jsonPath() - .get("id"); + .get(FIELD_ID); } @NotNull @@ -310,30 +326,30 @@ private String createAnnotationSet() { final JSONObject jsonObject = new JSONObject(); final UUID newAnnotationSetId = UUID.randomUUID(); jsonObject.put("documentId", UUID.randomUUID().toString()); - jsonObject.put("id", newAnnotationSetId.toString()); + jsonObject.put(FIELD_ID, newAnnotationSetId.toString()); return request .body(jsonObject.toString()) - .post("/api/annotation-sets") + .post(API_ANNOTATION_SETS) .then() - .statusCode(201) - .body("id", equalTo(newAnnotationSetId.toString())) + .statusCode(STATUS_CREATED) + .body(FIELD_ID, equalTo(newAnnotationSetId.toString())) .extract() .response() .getBody() .jsonPath() - .get("id"); + .get(FIELD_ID); } @NotNull private JSONObject createRectanglePayload(String annotationId, String rectangleId) { final JSONObject rectangle = new JSONObject(); - rectangle.put("id", rectangleId); - rectangle.put("annotationId", annotationId); - rectangle.put("x", 1f); - rectangle.put("y", 2f); - rectangle.put("width", 10f); - rectangle.put("height", 11f); + rectangle.put(FIELD_ID, rectangleId); + rectangle.put(FIELD_ANNOTATION_ID, annotationId); + rectangle.put(FIELD_X, DEFAULT_X); + rectangle.put(FIELD_Y, DEFAULT_Y); + rectangle.put(FIELD_WIDTH, DEFAULT_WIDTH); + rectangle.put(FIELD_HEIGHT, DEFAULT_HEIGHT); return rectangle; } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TagScenariosTest.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TagScenariosTest.java index aaec7349..ca65d98a 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TagScenariosTest.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TagScenariosTest.java @@ -6,6 +6,8 @@ import org.json.JSONArray; import org.json.JSONObject; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import uk.gov.hmcts.reform.em.annotation.testutil.TestUtil; import java.util.UUID; @@ -13,6 +15,11 @@ class TagScenariosTest extends BaseTest { + @Autowired + public TagScenariosTest(TestUtil testUtil) { + super(testUtil); + } + @Test void shouldReturn200WhenGetTagByCreatedBy() { final String annotationSetId = createAnnotationSet(); @@ -45,11 +52,11 @@ void shouldReturn401WhenUnAuthenticatedUserGetTagByCreatedBy() { } @Test - void shouldReturn404WhenGetTagByCreatedByNotFound() { + void shouldReturn200WhenGetTagByCreatedByNotFound() { request .get("/api/tags/foo") .then() - .statusCode(200) //FIXME should return 404 + .statusCode(200) .log().all(); } diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TestConsts.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TestConsts.java new file mode 100644 index 00000000..08f40a15 --- /dev/null +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/functional/TestConsts.java @@ -0,0 +1,104 @@ +package uk.gov.hmcts.reform.em.annotation.functional; + +import org.springframework.http.MediaType; + +public final class TestConsts { + // 🔹 API Endpoints + public static final String API_ANNOTATIONS = "/api/annotations"; + public static final String API_ANNOTATION_SETS = "/api/annotation-sets"; + public static final String BOOKMARKS = "/%s/bookmarks"; + public static final String API_BASE = "/api"; + public static final String API_BOOKMARKS = API_BASE + "/bookmarks"; + public static final String API_BOOKMARKS_MULTIPLE = API_BASE + "/bookmarks_multiple"; + public static final String API_COMMENTS = "/api/comments"; + public static final String API_FILTER = API_ANNOTATION_SETS + "/filter"; + public static final String API_METADATA = "/api/metadata/"; + public static final String API_RECTANGLES = "/api/rectangles"; + public static final String API_RECTANGLES_ID = API_RECTANGLES + "/"; + + // 🔹 JSON field keys + public static final String FIELD_ID = "id"; + public static final String FIELD_PAGE = "page"; + public static final String FIELD_COLOR = "color"; + public static final String FIELD_DOCUMENT_ID = "documentId"; + public static final String FIELD_ANNOTATION_ID = "annotationId"; + public static final String FIELD_ANNOTATION_SET_ID = "annotationSetId"; + public static final String FIELD_ANNOTATION_TYPE = "annotationType"; + public static final String FIELD_COMMENTS = "comments"; + public static final String FIELD_RECTANGLES = "rectangles"; + public static final String FIELD_CONTENT = "content"; + public static final String FIELD_X = "x"; + public static final String FIELD_Y = "y"; + public static final String FIELD_WIDTH = "width"; + public static final String FIELD_HEIGHT = "height"; + public static final String FIELD_CASE_ID = "caseId"; + public static final String FIELD_JURISDICTION = "jurisdiction"; + public static final String FIELD_COMMENT_HEADER = "commentHeader"; + public static final String FIELD_ANNOTATIONS = "annotations"; + public static final String HEADER_LOCATION = "Location"; + public static final String VALUE_HIGHLIGHT = "highlight"; + public static final String VALUE_COLOR = "d1d1d1"; + public static final String VALUE_TEXT = "text"; + + public static final String FIELD_NAME = "name"; + public static final String FIELD_CREATED_BY = "createdBy"; + public static final String FIELD_PAGE_NUMBER = "pageNumber"; + public static final String FIELD_X_COORD = "xCoordinate"; + public static final String FIELD_Y_COORD = "yCoordinate"; + public static final String FIELD_PARENT = "parent"; + public static final String FIELD_PREVIOUS = "previous"; + public static final String FIELD_DELETED = "deleted"; + public static final String FIELD_ROTATION_ANGLE = "rotationAngle"; + public static final String FIELD_ERRORS = "fieldErrors"; + + public static final String CREATED_BY_USER = "user"; + public static final String BOOKMARK_NAME = "Bookmark for test"; + public static final float DEFAULT_COORD = 100f; + public static final int DEFAULT_PAGE = 1; + + public static final String DEFAULT_CONTENT = "text"; + public static final String UPDATED_CONTENT = "updated text"; + public static final String NEW_CONTENT = "new text"; + public static final String HIGHLIGHT = "highlight"; + public static final String COLOR_CODE = "d1d1d1"; + + + // 🔹 Common values + public static final String COLOR_DEFAULT = "d1d1d1"; + public static final String COLOR_UPDATED = "f1f1f1"; + public static final String COLOR_SECOND_UPDATE = "e1e1e1"; + public static final String ANNOTATION_TYPE_HIGHLIGHT = "highlight"; + public static final String COMMENT_TEXT = "text"; + public static final String LOCATION_HEADER = "Location"; + public static final String PUBLIC_LAW = "PUBLICLAW"; + + public static final int DEFAULT_ROTATION_ANGLE = 90; + public static final String VALIDATION_NOT_NULL = "NotNull"; + + public static final String FIELD = "field"; + public static final String MESSAGE = "message"; + + public static final float DEFAULT_X = 1f; + public static final float DEFAULT_Y = 2f; + public static final float DEFAULT_WIDTH = 10f; + public static final float DEFAULT_HEIGHT = 11f; + + public static final String DEFAULT_ANNOTATION_TYPE = "highlight"; + public static final String DEFAULT_COLOR = "d1d1d1"; + + public static final String HEADER_LOCATION_TEMPLATE = API_RECTANGLES_ID; + + public static final String CONTENT_TYPE_JSON = MediaType.APPLICATION_JSON_VALUE; + + // === HTTP Status Codes === + public static final int STATUS_CREATED = 201; + public static final int STATUS_BAD_REQUEST = 400; + public static final int STATUS_UNAUTHORIZED = 401; + public static final int STATUS_OK = 200; + public static final int STATUS_NO_CONTENT = 204; + public static final int STATUS_NOT_FOUND = 404; + public static final int STATUS_INTERNAL_SERVER_ERROR = 500; + + private TestConsts() { + } +} diff --git a/src/aat/java/uk/gov/hmcts/reform/em/annotation/testutil/TestUtil.java b/src/aat/java/uk/gov/hmcts/reform/em/annotation/testutil/TestUtil.java index 91c8ac0c..ab7be53e 100644 --- a/src/aat/java/uk/gov/hmcts/reform/em/annotation/testutil/TestUtil.java +++ b/src/aat/java/uk/gov/hmcts/reform/em/annotation/testutil/TestUtil.java @@ -23,38 +23,46 @@ @EnableAutoConfiguration public class TestUtil { - @Autowired - private IdamHelper idamHelper; + public static final String AUTHORIZATION = "Authorization"; + public static final String SERVICE_AUTHORIZATION = "ServiceAuthorization"; + private final IdamHelper idamHelper; - @Autowired - private S2sHelper s2sHelper; + private final S2sHelper s2sHelper; - @Autowired - private CcdDataHelper ccdDataHelper; + private final CcdDataHelper ccdDataHelper; private String idamAuth; private String s2sAuth; - private final String username = "emAnnotationTestUser@test.local"; + private static final String ANNOTATION_TEST_USER_TEST_LOCAL = "emAnnotationTestUser@test.local"; + + @Autowired + public TestUtil(IdamHelper idamHelper, S2sHelper s2sHelper, CcdDataHelper ccdDataHelper) { + this.idamHelper = idamHelper; + this.s2sHelper = s2sHelper; + this.ccdDataHelper = ccdDataHelper; + } @PostConstruct void postConstruct() { SerenityRest.useRelaxedHTTPSValidation(); - idamHelper.createUser(username, Stream.of("caseworker", "caseworker-publiclaw").toList()); - idamAuth = idamHelper.authenticateUser(username); + idamHelper + .createUser(ANNOTATION_TEST_USER_TEST_LOCAL, + Stream.of("caseworker", "caseworker-publiclaw").toList()); + idamAuth = idamHelper.authenticateUser(ANNOTATION_TEST_USER_TEST_LOCAL); s2sAuth = s2sHelper.getS2sToken(); } @PreDestroy void preDestroy() { - idamHelper.deleteUser(username); + idamHelper.deleteUser(ANNOTATION_TEST_USER_TEST_LOCAL); } public RequestSpecification authRequest() { return SerenityRest .given() - .header("Authorization", idamHelper.authenticateUser(username)) - .header("ServiceAuthorization", s2sHelper.getS2sToken()); + .header(AUTHORIZATION, idamHelper.authenticateUser(ANNOTATION_TEST_USER_TEST_LOCAL)) + .header(SERVICE_AUTHORIZATION, s2sHelper.getS2sToken()); } public RequestSpecification unauthenticatedRequest() { @@ -63,53 +71,53 @@ public RequestSpecification unauthenticatedRequest() { public RequestSpecification emptyIdamAuthRequest() { return s2sAuthRequest() - .header(new Header("Authorization", null)); + .header(new Header(AUTHORIZATION, null)); } public RequestSpecification emptyIdamAuthAndEmptyS2SAuth() { return SerenityRest .given() - .header(new Header("ServiceAuthorization", null)) - .header(new Header("Authorization", null)); + .header(new Header(SERVICE_AUTHORIZATION, null)) + .header(new Header(AUTHORIZATION, null)); } public RequestSpecification validAuthRequestWithEmptyS2SAuth() { - return emptyS2sAuthRequest().header("Authorization", idamAuth); + return emptyS2sAuthRequest().header(AUTHORIZATION, idamAuth); } public RequestSpecification validS2SAuthWithEmptyIdamAuth() { - return s2sAuthRequest().header(new Header("Authorization", null)); + return s2sAuthRequest().header(new Header(AUTHORIZATION, null)); } private RequestSpecification emptyS2sAuthRequest() { - return SerenityRest.given().header(new Header("ServiceAuthorization", null)); + return SerenityRest.given().header(new Header(SERVICE_AUTHORIZATION, null)); } public RequestSpecification invalidIdamAuthrequest() { - return s2sAuthRequest().header("Authorization", "invalidIDAMAuthRequest"); + return s2sAuthRequest().header(AUTHORIZATION, "invalidIDAMAuthRequest"); } public RequestSpecification invalidS2SAuth() { - return invalidS2sAuthRequest().header("Authorization", idamAuth); + return invalidS2sAuthRequest().header(AUTHORIZATION, idamAuth); } private RequestSpecification invalidS2sAuthRequest() { - return SerenityRest.given().header("ServiceAuthorization", "invalidS2SAuthorization"); + return SerenityRest.given().header(SERVICE_AUTHORIZATION, "invalidS2SAuthorization"); } private RequestSpecification s2sAuthRequest() { return SerenityRest .given() - .header("ServiceAuthorization", s2sAuth); + .header(SERVICE_AUTHORIZATION, s2sAuth); } public CaseDetails createCase(String jurisdiction, String caseType, Object data) { - return ccdDataHelper.createCase(username, jurisdiction, caseType, "createCase", data); + return ccdDataHelper.createCase(ANNOTATION_TEST_USER_TEST_LOCAL, jurisdiction, caseType, "createCase", data); } }