fix for flaky failing fts

src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessSpec.java

@@ -0,0 +1,77 @@
+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 String userEmail;
+    private final String userPasswordEnvironmentVariable;
+    private final List<RequiredField> requiredFields;
+    private final List<String> definitionEventIds;
+
+    DefinitionReadinessSpec(String caseTypeId,
+                            String dataStoreReadinessEventId,
+                            String accessRole,
+                            String userEmail,
+                            String userPasswordEnvironmentVariable,
+                            List<RequiredField> requiredFields,
+                            List<String> 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);
+    }
+
+    String caseTypeId() {
+        return caseTypeId;
+    }
+
+    String dataStoreReadinessEventId() {
+        return dataStoreReadinessEventId;
+    }
+
+    String accessRole() {
+        return accessRole;
+    }
+
+    String userEmail() {
+        return userEmail;
+    }
+
+    String userPasswordEnvironmentVariable() {
+        return userPasswordEnvironmentVariable;
+    }
+
+    List<RequiredField> requiredFields() {
+        return requiredFields;
+    }
+
+    List<String> 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;
+        }
+    }
+}

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<String> 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<String> jsonStringSet(JsonPath jsonPath, String path) {
+        List<String> values = jsonPath.getList(path, String.class);
+        return values == null ? Collections.emptySet() : Set.copyOf(values);
+    }
+}

src/aat/java/uk/gov/hmcts/ccd/datastore/befta/DefinitionReadinessVerifierTest.java

@@ -0,0 +1,172 @@
+package uk.gov.hmcts.ccd.datastore.befta;
+
+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 DefinitionReadinessVerifierTest {
+
+    private static final DefinitionReadinessSpec SPEC = new DefinitionReadinessSpec(
+        "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")
+        ),
+        List.of("createCase", "updateCase")
+    );
+
+    @Test
+    void shouldAcceptDefinitionWithRequiredConfiguration() {
+        assertThatCode(() -> DefinitionReadinessVerifier.verify(JsonPath.from(validDefinition()), SPEC))
+            .doesNotThrowAnyException();
+    }
+
+    @Test
+    void shouldAcceptVisibleFieldsWithoutDefinitionAclOrEventMappings() {
+        assertThatCode(() -> DefinitionReadinessVerifier.verifyVisibleFields(JsonPath.from(visibleFields()), SPEC))
+            .doesNotThrowAnyException();
+    }
+
+    @Test
+    void shouldRejectDefinitionMissingRequiredField() {
+        String definition = validDefinition().replace(
+            "\"id\": \"RichTextAreaMinField\"",
+            "\"id\": \"OtherField\""
+        );
+
+        assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC))
+            .isInstanceOf(IllegalStateException.class)
+            .hasMessageContaining("missing required RichTextArea field RichTextAreaMinField");
+    }
+
+    @Test
+    void shouldRejectDefinitionWhenFieldBaseTypeIsWrong() {
+        String definition = validDefinition().replace(
+            "\"type\": \"RichTextArea\"",
+            "\"type\": \"Text\""
+        );
+
+        assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC))
+            .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");
+
+        assertThatThrownBy(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC))
+            .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(() -> DefinitionReadinessVerifier.verify(JsonPath.from(definition), SPEC))
+            .isInstanceOf(IllegalStateException.class)
+            .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() {
+        return """
+            {
+              "case_fields": [
+                {
+                  "id": "RichTextAreaField",
+                  "field_type": {
+                    "id": "RichTextArea",
+                    "type": "RichTextArea"
+                  },
+                  "acls": [
+                    {
+                      "role": "caseworker-befta_master",
+                      "create": true,
+                      "read": true,
+                      "update": true,
+                      "delete": true
+                    }
+                  ]
+                },
+                {
+                  "id": "RichTextAreaMinField",
+                  "field_type": {
+                    "id": "RichTextAreaMinField-3c359e9e-3b68-43a7-9948-2001ac9b4daf",
+                    "type": "RichTextArea",
+                    "min": 10
+                  },
+                  "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"
+                    }
+                  ]
+                }
+              ]
+            }
+            """;
+    }
+}