From e64a6a457f3473941ef6379bcaceafd88c4219de Mon Sep 17 00:00:00 2001 From: Dinesh Patel Date: Fri, 4 Sep 2026 16:03:05 +0100 Subject: [PATCH 1/4] fix for flaky failing fts --- .../befta/HighLevelDataSetupApp.java | 21 +++- .../befta/RichTextAreaDefinitionVerifier.java | 103 ++++++++++++++++ .../RichTextAreaDefinitionVerifierTest.java | 112 ++++++++++++++++++ 3 files changed, 235 insertions(+), 1 deletion(-) create mode 100644 src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java create mode 100644 src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java index be3033612b..c90b65070d 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java @@ -5,6 +5,9 @@ import java.util.Locale; +import io.restassured.RestAssured; +import io.restassured.response.Response; + public class HighLevelDataSetupApp extends DataLoaderToDefinitionStore { public HighLevelDataSetupApp(CcdEnvironment dataSetupEnvironment) { @@ -19,7 +22,23 @@ public static void main(String[] args) throws Throwable { @Override protected boolean shouldTolerateDataSetupFailure() { - return true; + return false; + } + + @Override + public synchronized void loadDataIfNotLoadedVeryRecently() { + super.loadDataIfNotLoadedVeryRecently(); + verifyRichTextAreaDefinitionIsAvailable(); + } + + private void verifyRichTextAreaDefinitionIsAvailable() { + RestAssured.useRelaxedHTTPSValidation(); + + Response response = asAutoTestImporter() + .when() + .get("/api/data/case-type/{caseTypeId}", RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE); + + RichTextAreaDefinitionVerifier.verify(response); } } diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java new file mode 100644 index 0000000000..1ec11987a0 --- /dev/null +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java @@ -0,0 +1,103 @@ +package uk.gov.hmcts.ccd.datastore.befta; + +import io.restassured.path.json.JsonPath; +import io.restassured.response.Response; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +final class RichTextAreaDefinitionVerifier { + + static final String MASTER_CASE_TYPE = "FT_MasterCaseType"; + + private static final String RICH_TEXT_AREA_TYPE = "RichTextArea"; + private static final String BEFTA_MASTER_CASEWORKER_ROLE = "caseworker-befta_master"; + private static final Set REQUIRED_RICH_TEXT_AREA_FIELDS = Set.of( + "RichTextAreaField", + "RichTextAreaMinField" + ); + private static final Set REQUIRED_RICH_TEXT_AREA_EVENTS = Set.of( + "createCase", + "updateCase" + ); + + private RichTextAreaDefinitionVerifier() { + } + + static void verify(Response response) { + if (response.getStatusCode() != 200) { + throw new IllegalStateException("Could not verify " + MASTER_CASE_TYPE + + " after data setup. Definition Store returned HTTP " + response.getStatusCode() + + ": " + response.getBody().asString()); + } + + verify(response.jsonPath()); + } + + static void verify(JsonPath jsonPath) { + REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyRequiredRichTextAreaField(jsonPath, fieldId)); + REQUIRED_RICH_TEXT_AREA_EVENTS.forEach(eventId -> verifyRequiredRichTextAreaEvent(jsonPath, eventId)); + } + + private static void verifyRequiredRichTextAreaField(JsonPath jsonPath, String fieldId) { + String fieldPath = String.format("case_fields.find { it.id == '%s' }", fieldId); + Object caseField = jsonPath.get(fieldPath); + if (!(caseField instanceof Map)) { + throw new IllegalStateException(MASTER_CASE_TYPE + " is missing required RichTextArea field " + + fieldId + " after data setup."); + } + + String fieldType = jsonPath.getString(fieldPath + ".field_type.id"); + if (!RICH_TEXT_AREA_TYPE.equals(fieldType)) { + throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId + + " must be type " + RICH_TEXT_AREA_TYPE + " after data setup but was " + fieldType + "."); + } + + verifyCaseworkerCrudAccess(jsonPath, fieldId); + } + + private static void verifyCaseworkerCrudAccess(JsonPath jsonPath, String fieldId) { + String aclPath = String.format( + "case_fields.find { it.id == '%s' }.acls.find { it.role == '%s' }", + fieldId, + BEFTA_MASTER_CASEWORKER_ROLE + ); + Object acl = jsonPath.get(aclPath); + if (!(acl instanceof Map)) { + throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId + + " is missing " + BEFTA_MASTER_CASEWORKER_ROLE + " ACL after data setup."); + } + + if (!Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".create")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".read")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".update")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".delete"))) { + throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId + + " must grant CRUD to " + BEFTA_MASTER_CASEWORKER_ROLE + " after data setup."); + } + } + + private static void verifyRequiredRichTextAreaEvent(JsonPath jsonPath, String eventId) { + String eventPath = String.format("events.find { it.id == '%s' }", eventId); + Object event = jsonPath.get(eventPath); + if (!(event instanceof Map)) { + throw new IllegalStateException(MASTER_CASE_TYPE + " is missing required RichTextArea event " + + eventId + " after data setup."); + } + + Set activeEventFields = jsonStringSet(jsonPath, eventPath + ".case_fields.case_field_id"); + REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> { + if (!activeEventFields.contains(fieldId)) { + throw new IllegalStateException(MASTER_CASE_TYPE + " event " + eventId + + " is missing required RichTextArea field " + fieldId + " after data setup."); + } + }); + } + + private static Set jsonStringSet(JsonPath jsonPath, String path) { + List values = jsonPath.getList(path, String.class); + return values == null ? Collections.emptySet() : Set.copyOf(values); + } +} diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java new file mode 100644 index 0000000000..24b88520cc --- /dev/null +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java @@ -0,0 +1,112 @@ +package uk.gov.hmcts.ccd.datastore.befta; + +import io.restassured.path.json.JsonPath; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class RichTextAreaDefinitionVerifierTest { + + @Test + void shouldAcceptDefinitionWithRequiredRichTextAreaConfiguration() { + assertThatCode(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(validDefinition()))) + .doesNotThrowAnyException(); + } + + @Test + void shouldRejectDefinitionMissingRichTextAreaField() { + String definition = validDefinition().replace( + "\"id\": \"RichTextAreaMinField\"", + "\"id\": \"OtherField\"" + ); + + assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("missing required RichTextArea field RichTextAreaMinField"); + } + + @Test + void shouldRejectDefinitionMissingCaseworkerCrudAccess() { + String definition = validDefinition().replace("\"update\": true", "\"update\": false"); + + assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("must grant CRUD to caseworker-befta_master"); + } + + @Test + void shouldRejectDefinitionMissingEventFieldMapping() { + String definition = validDefinition().replace( + "\"case_field_id\": \"RichTextAreaMinField\"", + "\"case_field_id\": \"OtherField\"" + ); + + assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("event createCase is missing required RichTextArea field RichTextAreaMinField"); + } + + private String validDefinition() { + return """ + { + "case_fields": [ + { + "id": "RichTextAreaField", + "field_type": { + "id": "RichTextArea" + }, + "acls": [ + { + "role": "caseworker-befta_master", + "create": true, + "read": true, + "update": true, + "delete": true + } + ] + }, + { + "id": "RichTextAreaMinField", + "field_type": { + "id": "RichTextArea" + }, + "acls": [ + { + "role": "caseworker-befta_master", + "create": true, + "read": true, + "update": true, + "delete": true + } + ] + } + ], + "events": [ + { + "id": "createCase", + "case_fields": [ + { + "case_field_id": "RichTextAreaField" + }, + { + "case_field_id": "RichTextAreaMinField" + } + ] + }, + { + "id": "updateCase", + "case_fields": [ + { + "case_field_id": "RichTextAreaField" + }, + { + "case_field_id": "RichTextAreaMinField" + } + ] + } + ] + } + """; + } +} From cafacde4553f29b8effca6dc736438e5b5002a94 Mon Sep 17 00:00:00 2001 From: Dinesh Patel Date: Fri, 4 Sep 2026 16:39:13 +0100 Subject: [PATCH 2/4] changed the verifier to use field_type.type, so this generated ID case will pass without weakening the check into fuzzy matching --- .../befta/HighLevelDataSetupApp.java | 90 +++++++++++++++++++ .../befta/RichTextAreaDefinitionVerifier.java | 11 ++- .../RichTextAreaDefinitionVerifierTest.java | 51 ++++++++++- 3 files changed, 145 insertions(+), 7 deletions(-) diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java index c90b65070d..669e5993dc 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java @@ -1,15 +1,31 @@ package uk.gov.hmcts.ccd.datastore.befta; +import uk.gov.hmcts.befta.BeftaMain; +import uk.gov.hmcts.befta.DefaultTestAutomationAdapter; +import uk.gov.hmcts.befta.auth.UserTokenProviderConfig; +import uk.gov.hmcts.befta.data.UserData; import uk.gov.hmcts.befta.dse.ccd.CcdEnvironment; import uk.gov.hmcts.befta.dse.ccd.DataLoaderToDefinitionStore; +import uk.gov.hmcts.befta.util.EnvironmentVariableUtils; +import uk.gov.hmcts.ccd.v2.V2; import java.util.Locale; +import java.util.concurrent.ExecutionException; +import java.util.function.Supplier; import io.restassured.RestAssured; +import io.restassured.builder.RequestSpecBuilder; import io.restassured.response.Response; +import io.restassured.specification.RequestSpecification; public class HighLevelDataSetupApp extends DataLoaderToDefinitionStore { + private static final String BEFTA_MASTER_CASEWORKER_EMAIL = "master.caseworker@gmail.com"; + private static final String BEFTA_MASTER_CASEWORKER_PASSWORD_ENV = "CCD_BEFTA_MASTER_CASEWORKER_PWD"; + private static final String CREATE_CASE_EVENT = "createCase"; + private static final int DATA_STORE_READINESS_ATTEMPTS = 45; + private static final long DATA_STORE_READINESS_POLL_INTERVAL_MILLIS = 1_000L; + public HighLevelDataSetupApp(CcdEnvironment dataSetupEnvironment) { super(dataSetupEnvironment); } @@ -29,6 +45,7 @@ protected boolean shouldTolerateDataSetupFailure() { public synchronized void loadDataIfNotLoadedVeryRecently() { super.loadDataIfNotLoadedVeryRecently(); verifyRichTextAreaDefinitionIsAvailable(); + waitUntilDataStoreRichTextAreaDefinitionIsReady(); } private void verifyRichTextAreaDefinitionIsAvailable() { @@ -41,4 +58,77 @@ private void verifyRichTextAreaDefinitionIsAvailable() { RichTextAreaDefinitionVerifier.verify(response); } + private void waitUntilDataStoreRichTextAreaDefinitionIsReady() { + Supplier asBeftaMasterCaseworker = asBeftaMasterCaseworker(); + RuntimeException lastFailure = null; + + for (int attempt = 1; attempt <= DATA_STORE_READINESS_ATTEMPTS; attempt++) { + try { + Response response = asBeftaMasterCaseworker.get() + .given() + .pathParam("caseTypeId", RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE) + .pathParam("triggerId", CREATE_CASE_EVENT) + .accept(V2.MediaType.CASE_TYPE_UPDATE_VIEW_EVENT) + .header(V2.EXPERIMENTAL_HEADER, "true") + .when() + .get("/internal/case-types/{caseTypeId}/event-triggers/{triggerId}?ignore-warning=true"); + + verifyDataStoreRichTextAreaStartTrigger(response); + return; + } catch (RuntimeException e) { + lastFailure = e; + if (attempt < DATA_STORE_READINESS_ATTEMPTS) { + waitBeforeNextDataStoreReadinessAttempt(); + } + } + } + + throw new IllegalStateException("Data Store did not serve the RichTextArea fields for " + + RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE + " " + CREATE_CASE_EVENT + " after " + + DATA_STORE_READINESS_ATTEMPTS + " attempts. The service is likely still using a cached " + + "case definition from before highLevelDataSetup completed.", lastFailure); + } + + private void verifyDataStoreRichTextAreaStartTrigger(Response response) { + if (response.getStatusCode() != 200) { + throw new IllegalStateException("Could not verify Data Store start trigger for " + + RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE + " " + CREATE_CASE_EVENT + + ". Data Store returned HTTP " + response.getStatusCode() + ": " + response.getBody().asString()); + } + + RichTextAreaDefinitionVerifier.verifyVisibleFields(response.jsonPath()); + } + + private Supplier asBeftaMasterCaseworker() { + DefaultTestAutomationAdapter adapter = new DefaultTestAutomationAdapter(); + UserData caseworker = new UserData( + BEFTA_MASTER_CASEWORKER_EMAIL, + EnvironmentVariableUtils.getRequiredVariable(BEFTA_MASTER_CASEWORKER_PASSWORD_ENV) + ); + + try { + adapter.authenticate(caseworker, UserTokenProviderConfig.DEFAULT_INSTANCE.getClientId()); + } catch (ExecutionException e) { + throw new IllegalStateException("Could not authenticate " + BEFTA_MASTER_CASEWORKER_EMAIL + + " for Data Store definition readiness check.", e); + } + + String s2sToken = adapter.getNewS2STokenWithEnvVars("CCD_API_GATEWAY_S2S_ID", "CCD_API_GATEWAY_S2S_KEY"); + + return () -> RestAssured.given(new RequestSpecBuilder() + .setBaseUri(BeftaMain.getConfig().getTestUrl()) + .build()) + .header("Authorization", "Bearer " + caseworker.getAccessToken()) + .header("ServiceAuthorization", s2sToken); + } + + private void waitBeforeNextDataStoreReadinessAttempt() { + try { + Thread.sleep(DATA_STORE_READINESS_POLL_INTERVAL_MILLIS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IllegalStateException("Interrupted while waiting for Data Store definition readiness.", e); + } + } + } diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java index 1ec11987a0..546772aa22 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java @@ -37,10 +37,15 @@ static void verify(Response response) { } static void verify(JsonPath jsonPath) { - REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyRequiredRichTextAreaField(jsonPath, fieldId)); + verifyVisibleFields(jsonPath); + REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyCaseworkerCrudAccess(jsonPath, fieldId)); REQUIRED_RICH_TEXT_AREA_EVENTS.forEach(eventId -> verifyRequiredRichTextAreaEvent(jsonPath, eventId)); } + static void verifyVisibleFields(JsonPath jsonPath) { + REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyRequiredRichTextAreaField(jsonPath, fieldId)); + } + private static void verifyRequiredRichTextAreaField(JsonPath jsonPath, String fieldId) { String fieldPath = String.format("case_fields.find { it.id == '%s' }", fieldId); Object caseField = jsonPath.get(fieldPath); @@ -49,13 +54,11 @@ private static void verifyRequiredRichTextAreaField(JsonPath jsonPath, String fi + fieldId + " after data setup."); } - String fieldType = jsonPath.getString(fieldPath + ".field_type.id"); + String fieldType = jsonPath.getString(fieldPath + ".field_type.type"); if (!RICH_TEXT_AREA_TYPE.equals(fieldType)) { throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId + " must be type " + RICH_TEXT_AREA_TYPE + " after data setup but was " + fieldType + "."); } - - verifyCaseworkerCrudAccess(jsonPath, fieldId); } private static void verifyCaseworkerCrudAccess(JsonPath jsonPath, String fieldId) { diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java index 24b88520cc..54ca6aab28 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java @@ -14,6 +14,12 @@ void shouldAcceptDefinitionWithRequiredRichTextAreaConfiguration() { .doesNotThrowAnyException(); } + @Test + void shouldAcceptVisibleFieldsWithoutDefinitionAclOrEventMappings() { + assertThatCode(() -> RichTextAreaDefinitionVerifier.verifyVisibleFields(JsonPath.from(visibleFields()))) + .doesNotThrowAnyException(); + } + @Test void shouldRejectDefinitionMissingRichTextAreaField() { String definition = validDefinition().replace( @@ -26,6 +32,18 @@ void shouldRejectDefinitionMissingRichTextAreaField() { .hasMessageContaining("missing required RichTextArea field RichTextAreaMinField"); } + @Test + void shouldRejectDefinitionWhenFieldBaseTypeIsWrong() { + String definition = validDefinition().replace( + "\"type\": \"RichTextArea\"", + "\"type\": \"Text\"" + ); + + assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("must be type RichTextArea after data setup but was Text"); + } + @Test void shouldRejectDefinitionMissingCaseworkerCrudAccess() { String definition = validDefinition().replace("\"update\": true", "\"update\": false"); @@ -44,7 +62,31 @@ void shouldRejectDefinitionMissingEventFieldMapping() { assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) .isInstanceOf(IllegalStateException.class) - .hasMessageContaining("event createCase is missing required RichTextArea field RichTextAreaMinField"); + .hasMessageContaining("is missing required RichTextArea field RichTextAreaMinField"); + } + + private String visibleFields() { + return """ + { + "case_fields": [ + { + "id": "RichTextAreaField", + "field_type": { + "id": "RichTextArea", + "type": "RichTextArea" + } + }, + { + "id": "RichTextAreaMinField", + "field_type": { + "id": "RichTextAreaMinField-3c359e9e-3b68-43a7-9948-2001ac9b4daf", + "type": "RichTextArea", + "min": 10 + } + } + ] + } + """; } private String validDefinition() { @@ -54,7 +96,8 @@ private String validDefinition() { { "id": "RichTextAreaField", "field_type": { - "id": "RichTextArea" + "id": "RichTextArea", + "type": "RichTextArea" }, "acls": [ { @@ -69,7 +112,9 @@ private String validDefinition() { { "id": "RichTextAreaMinField", "field_type": { - "id": "RichTextArea" + "id": "RichTextAreaMinField-3c359e9e-3b68-43a7-9948-2001ac9b4daf", + "type": "RichTextArea", + "min": 10 }, "acls": [ { From ed89c0bc31ba528d42e742a7b7e42bd6c7624ad8 Mon Sep 17 00:00:00 2001 From: Dinesh Patel Date: Mon, 7 Sep 2026 09:06:35 +0100 Subject: [PATCH 3/4] applied fix to make more generic --- .../befta/DefinitionReadinessSpec.java | 63 +++++++++++ .../befta/DefinitionReadinessVerifier.java | 97 ++++++++++++++++ ...a => DefinitionReadinessVerifierTest.java} | 31 +++-- .../befta/HighLevelDataSetupApp.java | 47 +++++--- .../befta/RichTextAreaDefinitionVerifier.java | 106 ------------------ 5 files changed, 212 insertions(+), 132 deletions(-) create mode 100644 src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java create mode 100644 src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifier.java rename src/aat/java/uk/gov/hmcts/ccd/datastore/befta/{RichTextAreaDefinitionVerifierTest.java => DefinitionReadinessVerifierTest.java} (78%) delete mode 100644 src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java new file mode 100644 index 0000000000..3b687df791 --- /dev/null +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java @@ -0,0 +1,63 @@ +package uk.gov.hmcts.ccd.datastore.befta; + +import java.util.List; + +final class DefinitionReadinessSpec { + + private final String caseTypeId; + private final String dataStoreReadinessEventId; + private final String accessRole; + private final List requiredFields; + private final List definitionEventIds; + + DefinitionReadinessSpec(String caseTypeId, + String dataStoreReadinessEventId, + String accessRole, + List requiredFields, + List definitionEventIds) { + this.caseTypeId = caseTypeId; + this.dataStoreReadinessEventId = dataStoreReadinessEventId; + this.accessRole = accessRole; + this.requiredFields = List.copyOf(requiredFields); + this.definitionEventIds = List.copyOf(definitionEventIds); + } + + String caseTypeId() { + return caseTypeId; + } + + String dataStoreReadinessEventId() { + return dataStoreReadinessEventId; + } + + String accessRole() { + return accessRole; + } + + List requiredFields() { + return requiredFields; + } + + List definitionEventIds() { + return definitionEventIds; + } + + static final class RequiredField { + + private final String id; + private final String type; + + RequiredField(String id, String type) { + this.id = id; + this.type = type; + } + + String id() { + return id; + } + + String type() { + return type; + } + } +} diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifier.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifier.java new file mode 100644 index 0000000000..976709f380 --- /dev/null +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifier.java @@ -0,0 +1,97 @@ +package uk.gov.hmcts.ccd.datastore.befta; + +import io.restassured.path.json.JsonPath; +import io.restassured.response.Response; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +final class DefinitionReadinessVerifier { + + private DefinitionReadinessVerifier() { + } + + static void verify(Response response, DefinitionReadinessSpec spec) { + if (response.getStatusCode() != 200) { + throw new IllegalStateException("Could not verify " + spec.caseTypeId() + + " after data setup. Definition Store returned HTTP " + response.getStatusCode() + + ": " + response.getBody().asString()); + } + + verify(response.jsonPath(), spec); + } + + static void verify(JsonPath jsonPath, DefinitionReadinessSpec spec) { + verifyVisibleFields(jsonPath, spec); + spec.requiredFields().forEach(field -> verifyCrudAccess(jsonPath, spec, field)); + spec.definitionEventIds().forEach(eventId -> verifyRequiredEvent(jsonPath, spec, eventId)); + } + + static void verifyVisibleFields(JsonPath jsonPath, DefinitionReadinessSpec spec) { + spec.requiredFields().forEach(field -> verifyRequiredField(jsonPath, spec, field)); + } + + private static void verifyRequiredField(JsonPath jsonPath, + DefinitionReadinessSpec spec, + DefinitionReadinessSpec.RequiredField field) { + String fieldPath = String.format("case_fields.find { it.id == '%s' }", field.id()); + Object caseField = jsonPath.get(fieldPath); + if (!(caseField instanceof Map)) { + throw new IllegalStateException(spec.caseTypeId() + " is missing required " + field.type() + + " field " + field.id() + " after data setup."); + } + + String fieldType = jsonPath.getString(fieldPath + ".field_type.type"); + if (!field.type().equals(fieldType)) { + throw new IllegalStateException(spec.caseTypeId() + " field " + field.id() + + " must be type " + field.type() + " after data setup but was " + fieldType + "."); + } + } + + private static void verifyCrudAccess(JsonPath jsonPath, + DefinitionReadinessSpec spec, + DefinitionReadinessSpec.RequiredField field) { + String aclPath = String.format( + "case_fields.find { it.id == '%s' }.acls.find { it.role == '%s' }", + field.id(), + spec.accessRole() + ); + Object acl = jsonPath.get(aclPath); + if (!(acl instanceof Map)) { + throw new IllegalStateException(spec.caseTypeId() + " field " + field.id() + + " is missing " + spec.accessRole() + " ACL after data setup."); + } + + if (!Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".create")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".read")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".update")) + || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".delete"))) { + throw new IllegalStateException(spec.caseTypeId() + " field " + field.id() + + " must grant CRUD to " + spec.accessRole() + " after data setup."); + } + } + + private static void verifyRequiredEvent(JsonPath jsonPath, DefinitionReadinessSpec spec, String eventId) { + String eventPath = String.format("events.find { it.id == '%s' }", eventId); + Object event = jsonPath.get(eventPath); + if (!(event instanceof Map)) { + throw new IllegalStateException(spec.caseTypeId() + " is missing required event " + + eventId + " after data setup."); + } + + Set activeEventFields = jsonStringSet(jsonPath, eventPath + ".case_fields.case_field_id"); + spec.requiredFields().forEach(field -> { + if (!activeEventFields.contains(field.id())) { + throw new IllegalStateException(spec.caseTypeId() + " event " + eventId + + " is missing required " + field.type() + " field " + field.id() + " after data setup."); + } + }); + } + + private static Set jsonStringSet(JsonPath jsonPath, String path) { + List values = jsonPath.getList(path, String.class); + return values == null ? Collections.emptySet() : Set.copyOf(values); + } +} diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java similarity index 78% rename from src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java rename to src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java index 54ca6aab28..c60c935129 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifierTest.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java @@ -3,31 +3,44 @@ import io.restassured.path.json.JsonPath; import org.junit.jupiter.api.Test; +import java.util.List; + import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; -class RichTextAreaDefinitionVerifierTest { +class DefinitionReadinessVerifierTest { + + private static final DefinitionReadinessSpec SPEC = new DefinitionReadinessSpec( + "FT_MasterCaseType", + "createCase", + "caseworker-befta_master", + List.of( + new DefinitionReadinessSpec.RequiredField("RichTextAreaField", "RichTextArea"), + new DefinitionReadinessSpec.RequiredField("RichTextAreaMinField", "RichTextArea") + ), + List.of("createCase", "updateCase") + ); @Test - void shouldAcceptDefinitionWithRequiredRichTextAreaConfiguration() { - assertThatCode(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(validDefinition()))) + void shouldAcceptDefinitionWithRequiredConfiguration() { + assertThatCode(() -> DefinitionReadinessVerifier.verify(JsonPath.from(validDefinition()), SPEC)) .doesNotThrowAnyException(); } @Test void shouldAcceptVisibleFieldsWithoutDefinitionAclOrEventMappings() { - assertThatCode(() -> RichTextAreaDefinitionVerifier.verifyVisibleFields(JsonPath.from(visibleFields()))) + assertThatCode(() -> DefinitionReadinessVerifier.verifyVisibleFields(JsonPath.from(visibleFields()), SPEC)) .doesNotThrowAnyException(); } @Test - void shouldRejectDefinitionMissingRichTextAreaField() { + void shouldRejectDefinitionMissingRequiredField() { String definition = validDefinition().replace( "\"id\": \"RichTextAreaMinField\"", "\"id\": \"OtherField\"" ); - assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("missing required RichTextArea field RichTextAreaMinField"); } @@ -39,7 +52,7 @@ void shouldRejectDefinitionWhenFieldBaseTypeIsWrong() { "\"type\": \"Text\"" ); - assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("must be type RichTextArea after data setup but was Text"); } @@ -48,7 +61,7 @@ void shouldRejectDefinitionWhenFieldBaseTypeIsWrong() { void shouldRejectDefinitionMissingCaseworkerCrudAccess() { String definition = validDefinition().replace("\"update\": true", "\"update\": false"); - assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("must grant CRUD to caseworker-befta_master"); } @@ -60,7 +73,7 @@ void shouldRejectDefinitionMissingEventFieldMapping() { "\"case_field_id\": \"OtherField\"" ); - assertThatThrownBy(() -> RichTextAreaDefinitionVerifier.verify(JsonPath.from(definition))) + assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("is missing required RichTextArea field RichTextAreaMinField"); } diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java index 669e5993dc..9b0c7c58a0 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java @@ -9,6 +9,7 @@ import uk.gov.hmcts.befta.util.EnvironmentVariableUtils; import uk.gov.hmcts.ccd.v2.V2; +import java.util.List; import java.util.Locale; import java.util.concurrent.ExecutionException; import java.util.function.Supplier; @@ -22,9 +23,21 @@ public class HighLevelDataSetupApp extends DataLoaderToDefinitionStore { private static final String BEFTA_MASTER_CASEWORKER_EMAIL = "master.caseworker@gmail.com"; private static final String BEFTA_MASTER_CASEWORKER_PASSWORD_ENV = "CCD_BEFTA_MASTER_CASEWORKER_PWD"; - private static final String CREATE_CASE_EVENT = "createCase"; private static final int DATA_STORE_READINESS_ATTEMPTS = 45; private static final long DATA_STORE_READINESS_POLL_INTERVAL_MILLIS = 1_000L; + private static final DefinitionReadinessSpec RICH_TEXT_AREA_READINESS_SPEC = new DefinitionReadinessSpec( + "FT_MasterCaseType", + "createCase", + "caseworker-befta_master", + List.of( + new DefinitionReadinessSpec.RequiredField("RichTextAreaField", "RichTextArea"), + new DefinitionReadinessSpec.RequiredField("RichTextAreaMinField", "RichTextArea") + ), + List.of("createCase", "updateCase") + ); + private static final List REQUIRED_DEFINITIONS = List.of( + RICH_TEXT_AREA_READINESS_SPEC + ); public HighLevelDataSetupApp(CcdEnvironment dataSetupEnvironment) { super(dataSetupEnvironment); @@ -44,21 +57,21 @@ protected boolean shouldTolerateDataSetupFailure() { @Override public synchronized void loadDataIfNotLoadedVeryRecently() { super.loadDataIfNotLoadedVeryRecently(); - verifyRichTextAreaDefinitionIsAvailable(); - waitUntilDataStoreRichTextAreaDefinitionIsReady(); + REQUIRED_DEFINITIONS.forEach(this::verifyDefinitionIsAvailable); + REQUIRED_DEFINITIONS.forEach(this::waitUntilDataStoreDefinitionIsReady); } - private void verifyRichTextAreaDefinitionIsAvailable() { + private void verifyDefinitionIsAvailable(DefinitionReadinessSpec spec) { RestAssured.useRelaxedHTTPSValidation(); Response response = asAutoTestImporter() .when() - .get("/api/data/case-type/{caseTypeId}", RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE); + .get("/api/data/case-type/{caseTypeId}", spec.caseTypeId()); - RichTextAreaDefinitionVerifier.verify(response); + DefinitionReadinessVerifier.verify(response, spec); } - private void waitUntilDataStoreRichTextAreaDefinitionIsReady() { + private void waitUntilDataStoreDefinitionIsReady(DefinitionReadinessSpec spec) { Supplier asBeftaMasterCaseworker = asBeftaMasterCaseworker(); RuntimeException lastFailure = null; @@ -66,14 +79,14 @@ private void waitUntilDataStoreRichTextAreaDefinitionIsReady() { try { Response response = asBeftaMasterCaseworker.get() .given() - .pathParam("caseTypeId", RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE) - .pathParam("triggerId", CREATE_CASE_EVENT) + .pathParam("caseTypeId", spec.caseTypeId()) + .pathParam("triggerId", spec.dataStoreReadinessEventId()) .accept(V2.MediaType.CASE_TYPE_UPDATE_VIEW_EVENT) .header(V2.EXPERIMENTAL_HEADER, "true") .when() .get("/internal/case-types/{caseTypeId}/event-triggers/{triggerId}?ignore-warning=true"); - verifyDataStoreRichTextAreaStartTrigger(response); + verifyDataStoreStartTrigger(response, spec); return; } catch (RuntimeException e) { lastFailure = e; @@ -83,20 +96,20 @@ private void waitUntilDataStoreRichTextAreaDefinitionIsReady() { } } - throw new IllegalStateException("Data Store did not serve the RichTextArea fields for " - + RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE + " " + CREATE_CASE_EVENT + " after " - + DATA_STORE_READINESS_ATTEMPTS + " attempts. The service is likely still using a cached " - + "case definition from before highLevelDataSetup completed.", lastFailure); + throw new IllegalStateException("Data Store did not serve the required fields for " + + spec.caseTypeId() + " " + spec.dataStoreReadinessEventId() + " after " + + DATA_STORE_READINESS_ATTEMPTS + " attempts. The service is likely still using a cached case definition " + + "from before highLevelDataSetup completed.", lastFailure); } - private void verifyDataStoreRichTextAreaStartTrigger(Response response) { + private void verifyDataStoreStartTrigger(Response response, DefinitionReadinessSpec spec) { if (response.getStatusCode() != 200) { throw new IllegalStateException("Could not verify Data Store start trigger for " - + RichTextAreaDefinitionVerifier.MASTER_CASE_TYPE + " " + CREATE_CASE_EVENT + + spec.caseTypeId() + " " + spec.dataStoreReadinessEventId() + ". Data Store returned HTTP " + response.getStatusCode() + ": " + response.getBody().asString()); } - RichTextAreaDefinitionVerifier.verifyVisibleFields(response.jsonPath()); + DefinitionReadinessVerifier.verifyVisibleFields(response.jsonPath(), spec); } private Supplier asBeftaMasterCaseworker() { diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java deleted file mode 100644 index 546772aa22..0000000000 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/RichTextAreaDefinitionVerifier.java +++ /dev/null @@ -1,106 +0,0 @@ -package uk.gov.hmcts.ccd.datastore.befta; - -import io.restassured.path.json.JsonPath; -import io.restassured.response.Response; - -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; - -final class RichTextAreaDefinitionVerifier { - - static final String MASTER_CASE_TYPE = "FT_MasterCaseType"; - - private static final String RICH_TEXT_AREA_TYPE = "RichTextArea"; - private static final String BEFTA_MASTER_CASEWORKER_ROLE = "caseworker-befta_master"; - private static final Set REQUIRED_RICH_TEXT_AREA_FIELDS = Set.of( - "RichTextAreaField", - "RichTextAreaMinField" - ); - private static final Set REQUIRED_RICH_TEXT_AREA_EVENTS = Set.of( - "createCase", - "updateCase" - ); - - private RichTextAreaDefinitionVerifier() { - } - - static void verify(Response response) { - if (response.getStatusCode() != 200) { - throw new IllegalStateException("Could not verify " + MASTER_CASE_TYPE - + " after data setup. Definition Store returned HTTP " + response.getStatusCode() - + ": " + response.getBody().asString()); - } - - verify(response.jsonPath()); - } - - static void verify(JsonPath jsonPath) { - verifyVisibleFields(jsonPath); - REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyCaseworkerCrudAccess(jsonPath, fieldId)); - REQUIRED_RICH_TEXT_AREA_EVENTS.forEach(eventId -> verifyRequiredRichTextAreaEvent(jsonPath, eventId)); - } - - static void verifyVisibleFields(JsonPath jsonPath) { - REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> verifyRequiredRichTextAreaField(jsonPath, fieldId)); - } - - private static void verifyRequiredRichTextAreaField(JsonPath jsonPath, String fieldId) { - String fieldPath = String.format("case_fields.find { it.id == '%s' }", fieldId); - Object caseField = jsonPath.get(fieldPath); - if (!(caseField instanceof Map)) { - throw new IllegalStateException(MASTER_CASE_TYPE + " is missing required RichTextArea field " - + fieldId + " after data setup."); - } - - String fieldType = jsonPath.getString(fieldPath + ".field_type.type"); - if (!RICH_TEXT_AREA_TYPE.equals(fieldType)) { - throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId - + " must be type " + RICH_TEXT_AREA_TYPE + " after data setup but was " + fieldType + "."); - } - } - - private static void verifyCaseworkerCrudAccess(JsonPath jsonPath, String fieldId) { - String aclPath = String.format( - "case_fields.find { it.id == '%s' }.acls.find { it.role == '%s' }", - fieldId, - BEFTA_MASTER_CASEWORKER_ROLE - ); - Object acl = jsonPath.get(aclPath); - if (!(acl instanceof Map)) { - throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId - + " is missing " + BEFTA_MASTER_CASEWORKER_ROLE + " ACL after data setup."); - } - - if (!Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".create")) - || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".read")) - || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".update")) - || !Boolean.TRUE.equals(jsonPath.getBoolean(aclPath + ".delete"))) { - throw new IllegalStateException(MASTER_CASE_TYPE + " field " + fieldId - + " must grant CRUD to " + BEFTA_MASTER_CASEWORKER_ROLE + " after data setup."); - } - } - - private static void verifyRequiredRichTextAreaEvent(JsonPath jsonPath, String eventId) { - String eventPath = String.format("events.find { it.id == '%s' }", eventId); - Object event = jsonPath.get(eventPath); - if (!(event instanceof Map)) { - throw new IllegalStateException(MASTER_CASE_TYPE + " is missing required RichTextArea event " - + eventId + " after data setup."); - } - - Set activeEventFields = jsonStringSet(jsonPath, eventPath + ".case_fields.case_field_id"); - REQUIRED_RICH_TEXT_AREA_FIELDS.forEach(fieldId -> { - if (!activeEventFields.contains(fieldId)) { - throw new IllegalStateException(MASTER_CASE_TYPE + " event " + eventId - + " is missing required RichTextArea field " + fieldId + " after data setup."); - } - }); - } - - private static Set jsonStringSet(JsonPath jsonPath, String path) { - List values = jsonPath.getList(path, String.class); - return values == null ? Collections.emptySet() : Set.copyOf(values); - } -} From b61a0b2d99b0fa0f75ee4f501de39f04b65474eb Mon Sep 17 00:00:00 2001 From: Dinesh Patel Date: Mon, 7 Sep 2026 09:33:20 +0100 Subject: [PATCH 4/4] fix missing secret error --- .../befta/DefinitionReadinessSpec.java | 14 ++++++++++++++ .../befta/DefinitionReadinessVerifierTest.java | 2 ++ .../datastore/befta/HighLevelDataSetupApp.java | 18 ++++++++++-------- .../S-127.1.td.json | 2 +- .../S-127.2.td.json | 2 +- ..._Create_Case_EventEnablingCondition.td.json | 2 +- ...ase_EventEnablingCondition_NotMatch.td.json | 2 +- .../common/S-127-GetToken_CaseCreate.td.json | 2 +- .../common/users/BeftaMasterCaseworker.td.json | 2 +- 9 files changed, 32 insertions(+), 14 deletions(-) diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java index 3b687df791..916a65597b 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java @@ -7,17 +7,23 @@ final class DefinitionReadinessSpec { private final String caseTypeId; private final String dataStoreReadinessEventId; private final String accessRole; + private final String userEmail; + private final String userPasswordEnvironmentVariable; private final List requiredFields; private final List definitionEventIds; DefinitionReadinessSpec(String caseTypeId, String dataStoreReadinessEventId, String accessRole, + String userEmail, + String userPasswordEnvironmentVariable, List requiredFields, List definitionEventIds) { this.caseTypeId = caseTypeId; this.dataStoreReadinessEventId = dataStoreReadinessEventId; this.accessRole = accessRole; + this.userEmail = userEmail; + this.userPasswordEnvironmentVariable = userPasswordEnvironmentVariable; this.requiredFields = List.copyOf(requiredFields); this.definitionEventIds = List.copyOf(definitionEventIds); } @@ -34,6 +40,14 @@ String accessRole() { return accessRole; } + String userEmail() { + return userEmail; + } + + String userPasswordEnvironmentVariable() { + return userPasswordEnvironmentVariable; + } + List requiredFields() { return requiredFields; } diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java index c60c935129..8b6fb07b8d 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java @@ -14,6 +14,8 @@ class DefinitionReadinessVerifierTest { "FT_MasterCaseType", "createCase", "caseworker-befta_master", + "master.caseworker@gmail.com", + "CCD_CASEWORKER_AUTOTEST_PASSWORD", List.of( new DefinitionReadinessSpec.RequiredField("RichTextAreaField", "RichTextArea"), new DefinitionReadinessSpec.RequiredField("RichTextAreaMinField", "RichTextArea") diff --git a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java index 9b0c7c58a0..8f1a31e436 100644 --- a/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java +++ b/src/aat/java/uk/gov/hmcts/ccd/datastore/befta/HighLevelDataSetupApp.java @@ -21,14 +21,16 @@ public class HighLevelDataSetupApp extends DataLoaderToDefinitionStore { - private static final String BEFTA_MASTER_CASEWORKER_EMAIL = "master.caseworker@gmail.com"; - private static final String BEFTA_MASTER_CASEWORKER_PASSWORD_ENV = "CCD_BEFTA_MASTER_CASEWORKER_PWD"; + private static final String MASTER_CASEWORKER_EMAIL = "master.caseworker@gmail.com"; + private static final String CASEWORKER_AUTOTEST_PASSWORD_ENV = "CCD_CASEWORKER_AUTOTEST_PASSWORD"; private static final int DATA_STORE_READINESS_ATTEMPTS = 45; private static final long DATA_STORE_READINESS_POLL_INTERVAL_MILLIS = 1_000L; private static final DefinitionReadinessSpec RICH_TEXT_AREA_READINESS_SPEC = new DefinitionReadinessSpec( "FT_MasterCaseType", "createCase", "caseworker-befta_master", + MASTER_CASEWORKER_EMAIL, + CASEWORKER_AUTOTEST_PASSWORD_ENV, List.of( new DefinitionReadinessSpec.RequiredField("RichTextAreaField", "RichTextArea"), new DefinitionReadinessSpec.RequiredField("RichTextAreaMinField", "RichTextArea") @@ -72,12 +74,12 @@ private void verifyDefinitionIsAvailable(DefinitionReadinessSpec spec) { } private void waitUntilDataStoreDefinitionIsReady(DefinitionReadinessSpec spec) { - Supplier asBeftaMasterCaseworker = asBeftaMasterCaseworker(); + Supplier asReadinessUser = asReadinessUser(spec); RuntimeException lastFailure = null; for (int attempt = 1; attempt <= DATA_STORE_READINESS_ATTEMPTS; attempt++) { try { - Response response = asBeftaMasterCaseworker.get() + Response response = asReadinessUser.get() .given() .pathParam("caseTypeId", spec.caseTypeId()) .pathParam("triggerId", spec.dataStoreReadinessEventId()) @@ -112,17 +114,17 @@ private void verifyDataStoreStartTrigger(Response response, DefinitionReadinessS DefinitionReadinessVerifier.verifyVisibleFields(response.jsonPath(), spec); } - private Supplier asBeftaMasterCaseworker() { + private Supplier asReadinessUser(DefinitionReadinessSpec spec) { DefaultTestAutomationAdapter adapter = new DefaultTestAutomationAdapter(); UserData caseworker = new UserData( - BEFTA_MASTER_CASEWORKER_EMAIL, - EnvironmentVariableUtils.getRequiredVariable(BEFTA_MASTER_CASEWORKER_PASSWORD_ENV) + spec.userEmail(), + EnvironmentVariableUtils.getRequiredVariable(spec.userPasswordEnvironmentVariable()) ); try { adapter.authenticate(caseworker, UserTokenProviderConfig.DEFAULT_INSTANCE.getClientId()); } catch (ExecutionException e) { - throw new IllegalStateException("Could not authenticate " + BEFTA_MASTER_CASEWORKER_EMAIL + throw new IllegalStateException("Could not authenticate " + spec.userEmail() + " for Data Store definition readiness check.", e); } diff --git a/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.1.td.json b/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.1.td.json index 1bd69991e9..40c7e44183 100644 --- a/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.1.td.json +++ b/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.1.td.json @@ -16,7 +16,7 @@ "user": { "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" }, "expectedResponse": { diff --git a/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.2.td.json b/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.2.td.json index 40a5bb8e81..61cbb76c2e 100644 --- a/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.2.td.json +++ b/src/aat/resources/features/F-127 - Even Enabling Condition/S-127.2.td.json @@ -16,7 +16,7 @@ "user": { "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" }, "expectedResponse": { diff --git a/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition.td.json b/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition.td.json index e6c1b5fb4f..288f48a7b3 100644 --- a/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition.td.json +++ b/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition.td.json @@ -13,7 +13,7 @@ "user": { "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" }, "request": { diff --git a/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition_NotMatch.td.json b/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition_NotMatch.td.json index e5dccd52f5..0eea572186 100644 --- a/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition_NotMatch.td.json +++ b/src/aat/resources/features/F-127 - Even Enabling Condition/common/FT_Create_Case_EventEnablingCondition_NotMatch.td.json @@ -13,7 +13,7 @@ "user": { "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" }, "request": { diff --git a/src/aat/resources/features/F-127 - Even Enabling Condition/common/S-127-GetToken_CaseCreate.td.json b/src/aat/resources/features/F-127 - Even Enabling Condition/common/S-127-GetToken_CaseCreate.td.json index bac913832d..2d8c41dde2 100644 --- a/src/aat/resources/features/F-127 - Even Enabling Condition/common/S-127-GetToken_CaseCreate.td.json +++ b/src/aat/resources/features/F-127 - Even Enabling Condition/common/S-127-GetToken_CaseCreate.td.json @@ -17,7 +17,7 @@ "users": { "invokingUser": { "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" } }, diff --git a/src/aat/resources/features/common/users/BeftaMasterCaseworker.td.json b/src/aat/resources/features/common/users/BeftaMasterCaseworker.td.json index bd3e6c32ba..79140beb42 100644 --- a/src/aat/resources/features/common/users/BeftaMasterCaseworker.td.json +++ b/src/aat/resources/features/common/users/BeftaMasterCaseworker.td.json @@ -2,5 +2,5 @@ "_guid_": "BeftaMasterCaseworker", "username": "master.caseworker@gmail.com", - "password": "[[$CCD_BEFTA_MASTER_CASEWORKER_PWD]]" + "password": "[[$CCD_CASEWORKER_AUTOTEST_PASSWORD]]" }