Fpvtl 2085

charts/prl-cos/values.preview.template.yaml

@@ -105,5 +105,7 @@ java:
     COMMON_DATA_API: http://rd-commondata-api-aat.service.core-compute-aat.internal
     SEND_LETTER_URL: http://rpe-send-letter-service-{{ .Values.global.environment }}.service.core-compute-{{ .Values.global.environment }}.internal
     BARRISTER_FEATURE_ENABLED: true
+    AWAITING_INFORMATION_ENABLED: true
+    EXIT_AWAITING_INFORMATION_ENABLED: true
     CAFCASS_DATE_TIME_FEATURE_ENABLED: true
     APP_ENV: "preview"

src/integrationTest/java/uk/gov/hmcts/reform/prl/controllers/CallbackControllerIntegrationTest.java

@@ -609,7 +609,7 @@ public void testFl401AddCaseNumberWhenStateIsNotInSubmitted() throws Exception {
                     .contentType(APPLICATION_JSON)
                     .content(jsonRequest))
             .andExpect(status().isOk())
-            .andExpect(jsonPath("$.data.isAddCaseNumberAdded").isEmpty())
+            .andExpect(jsonPath("$.data.isAddCaseNumberAdded").doesNotExist())
             .andReturn();
     }
 

src/integrationTest/java/uk/gov/hmcts/reform/prl/controllers/ExitAwaitingInformationControllerIntegrationTest.java

@@ -0,0 +1,160 @@
+package uk.gov.hmcts.reform.prl.controllers;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.servlet.ServletException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.web.context.WebApplicationContext;
+import uk.gov.hmcts.reform.ccd.client.model.CallbackRequest;
+import uk.gov.hmcts.reform.ccd.client.model.CaseDetails;
+import uk.gov.hmcts.reform.prl.enums.State;
+import uk.gov.hmcts.reform.prl.services.AuthorisationService;
+import uk.gov.hmcts.reform.prl.services.ExitAwaitingInformationService;
+import uk.gov.hmcts.reform.prl.services.FeatureToggleService;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.setup.MockMvcBuilders.webAppContextSetup;
+import static uk.gov.hmcts.reform.prl.constants.PrlAppsConstants.CASE_STATUS;
+import static uk.gov.hmcts.reform.prl.constants.PrlAppsConstants.SERVICE_AUTHORIZATION_HEADER;
+import static uk.gov.hmcts.reform.prl.constants.PrlAppsConstants.STATE_FIELD;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+@ContextConfiguration
+public class ExitAwaitingInformationControllerIntegrationTest {
+
+    private static final String AUTHORISATION_HEADER = "Authorization";
+    private static final String TEST_AUTH_TOKEN = "Bearer testAuthToken";
+    private static final String TEST_SERVICE_AUTH_TOKEN = "testServiceAuthToken";
+    private static final String URL = "/submit-exit-awaiting-information";
+    private static final long TEST_CASE_ID = 12345678L;
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext webApplicationContext;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @MockBean
+    private AuthorisationService authorisationService;
+
+    @MockBean
+    private ExitAwaitingInformationService exitAwaitingInformationService;
+
+    @MockBean
+    private FeatureToggleService featureToggleService;
+
+    @Before
+    public void setUp() {
+        mockMvc = webAppContextSetup(webApplicationContext).build();
+        when(featureToggleService.isExitAwaitingInformationEnabled()).thenReturn(true);
+    }
+
+    @Test
+    public void shouldSubmitExitAwaitingInformationSuccessfully() throws Exception {
+        when(authorisationService.isAuthorized(TEST_AUTH_TOKEN, TEST_SERVICE_AUTH_TOKEN)).thenReturn(true);
+        when(exitAwaitingInformationService.updateCase(any())).thenReturn(updatedCaseData());
+
+        mockMvc.perform(
+                post(URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.data.state").value(State.CASE_ISSUED.getValue()))
+            .andExpect(jsonPath("$.data.caseStatus.state").value(State.CASE_ISSUED.getLabel()))
+            .andExpect(jsonPath("$.data.existingField").value("existingValue"));
+
+        verify(exitAwaitingInformationService).updateCase(any());
+    }
+
+    @Test
+    public void shouldRejectSubmitExitAwaitingInformationWithoutAuthorizationHeader() throws Exception {
+        mockMvc.perform(
+                post(URL)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    public void shouldRejectSubmitExitAwaitingInformationWithoutServiceAuthorizationHeader() throws Exception {
+        mockMvc.perform(
+                post(URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    public void shouldRejectSubmitExitAwaitingInformationWithUnauthorizedTokens() throws Exception {
+        when(authorisationService.isAuthorized(TEST_AUTH_TOKEN, TEST_SERVICE_AUTH_TOKEN)).thenReturn(false);
+
+        ServletException exception = assertThrows(ServletException.class, () -> mockMvc.perform(
+                post(URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson())));
+
+        assertNotNull(exception.getCause());
+        assertEquals("Invalid Client", exception.getCause().getMessage());
+    }
+
+    private String validCallbackRequestJson() throws Exception {
+        Map<String, Object> caseData = new HashMap<>();
+        caseData.put("existingField", "existingValue");
+
+        CallbackRequest callbackRequest = CallbackRequest.builder()
+            .eventId("submit-exit-awaiting-information")
+            .caseDetails(CaseDetails.builder()
+                             .id(TEST_CASE_ID)
+                             .state(State.AWAITING_INFORMATION.getValue())
+                             .data(caseData)
+                             .build())
+            .caseDetailsBefore(CaseDetails.builder()
+                                   .id(TEST_CASE_ID)
+                                   .state(State.AWAITING_INFORMATION.getValue())
+                                   .data(new HashMap<>(caseData))
+                                   .build())
+            .build();
+
+        return objectMapper.writeValueAsString(callbackRequest);
+    }
+
+    private Map<String, Object> updatedCaseData() {
+        Map<String, Object> caseData = new HashMap<>();
+        caseData.put("existingField", "existingValue");
+        caseData.put(STATE_FIELD, State.CASE_ISSUED.getValue());
+        caseData.put(CASE_STATUS, Map.of("state", State.CASE_ISSUED.getLabel()));
+        return caseData;
+    }
+}

src/integrationTest/java/uk/gov/hmcts/reform/prl/controllers/RequestFurtherInformationControllerIntegrationTest.java

@@ -0,0 +1,216 @@
+package uk.gov.hmcts.reform.prl.controllers;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.servlet.ServletException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.web.context.WebApplicationContext;
+import uk.gov.hmcts.reform.ccd.client.model.CallbackRequest;
+import uk.gov.hmcts.reform.ccd.client.model.CaseDetails;
+import uk.gov.hmcts.reform.prl.models.complextypes.tab.summarytab.summary.CaseStatus;
+import uk.gov.hmcts.reform.prl.services.AuthorisationService;
+import uk.gov.hmcts.reform.prl.services.FeatureToggleService;
+import uk.gov.hmcts.reform.prl.services.RequestFurtherInformationService;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.setup.MockMvcBuilders.webAppContextSetup;
+import static uk.gov.hmcts.reform.prl.constants.PrlAppsConstants.CASE_STATUS;
+import static uk.gov.hmcts.reform.prl.constants.PrlAppsConstants.SERVICE_AUTHORIZATION_HEADER;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+@ContextConfiguration
+public class RequestFurtherInformationControllerIntegrationTest {
+
+    private static final String AUTHORISATION_HEADER = "Authorization";
+    private static final String TEST_AUTH_TOKEN = "Bearer testAuthToken";
+    private static final String TEST_SERVICE_AUTH_TOKEN = "testServiceAuthToken";
+    private static final String SUBMIT_URL = "/submit-request-further-information";
+    private static final String VALIDATE_URL = "/validate-request-further-information";
+    private static final long TEST_CASE_ID = 12345678L;
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext webApplicationContext;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @MockBean
+    private AuthorisationService authorisationService;
+
+    @MockBean
+    private RequestFurtherInformationService requestFurtherInformationService;
+
+    @MockBean
+    private FeatureToggleService featureToggleService;
+
+    @Before
+    public void setUp() {
+        mockMvc = webAppContextSetup(webApplicationContext).build();
+        when(featureToggleService.isAwaitingInformationEnabled()).thenReturn(true);
+    }
+
+    @Test
+    public void shouldSubmitAwaitingInformationSuccessfully() throws Exception {
+        when(authorisationService.isAuthorized(TEST_AUTH_TOKEN, TEST_SERVICE_AUTH_TOKEN)).thenReturn(true);
+        when(requestFurtherInformationService.addToCase(any())).thenReturn(submittedCaseData());
+
+        mockMvc.perform(
+                post(SUBMIT_URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.data.id").value(TEST_CASE_ID))
+            .andExpect(jsonPath("$.data.caseStatus.state").value("Awaiting information"))
+            .andExpect(jsonPath("$.data.applicantName").value("John Doe"))
+            .andExpect(jsonPath("$.data.respondentName").value("Jane Doe"));
+
+        verify(requestFurtherInformationService).addToCase(any());
+    }
+
+    @Test
+    public void shouldRejectSubmitAwaitingInformationWithoutAuthorizationHeader() throws Exception {
+        mockMvc.perform(
+                post(SUBMIT_URL)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    public void shouldRejectSubmitAwaitingInformationWithoutServiceAuthorizationHeader() throws Exception {
+        mockMvc.perform(
+                post(SUBMIT_URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    public void shouldRejectSubmitAwaitingInformationWithUnauthorizedTokens() throws Exception {
+        when(authorisationService.isAuthorized(TEST_AUTH_TOKEN, TEST_SERVICE_AUTH_TOKEN)).thenReturn(false);
+
+        ServletException exception = assertThrows(ServletException.class, () -> mockMvc.perform(
+                post(SUBMIT_URL)
+                    .header(AUTHORISATION_HEADER, TEST_AUTH_TOKEN)
+                    .header(SERVICE_AUTHORIZATION_HEADER, TEST_SERVICE_AUTH_TOKEN)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson())));
+
+        assertNotNull(exception.getCause());
+        assertEquals("Invalid Client", exception.getCause().getMessage());
+    }
+
+    @Test
+    public void shouldValidateAwaitingInformationSuccessfully() throws Exception {
+        when(requestFurtherInformationService.validate(any(CallbackRequest.class))).thenReturn(new ArrayList<>());
+
+        mockMvc.perform(
+                post(VALIDATE_URL)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.errors").isArray())
+            .andExpect(jsonPath("$.errors").isEmpty());
+    }
+
+    @Test
+    public void shouldValidateAwaitingInformationWithErrors() throws Exception {
+        when(requestFurtherInformationService.validate(any(CallbackRequest.class)))
+            .thenReturn(List.of("Please enter a future date"));
+
+        mockMvc.perform(
+                post(VALIDATE_URL)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.errors[0]").value("Please enter a future date"));
+    }
+
+    @Test
+    public void shouldReturnEmptyValidationErrorsWhenFeatureToggleDisabled() throws Exception {
+        when(featureToggleService.isAwaitingInformationEnabled()).thenReturn(false);
+
+        mockMvc.perform(
+                post(VALIDATE_URL)
+                    .accept(APPLICATION_JSON)
+                    .contentType(APPLICATION_JSON)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.errors").isArray())
+            .andExpect(jsonPath("$.errors").isEmpty());
+    }
+
+    @Test
+    public void shouldRejectValidationWithoutContentType() throws Exception {
+        mockMvc.perform(
+                post(VALIDATE_URL)
+                    .content(validCallbackRequestJson()))
+            .andExpect(status().isUnsupportedMediaType());
+    }
+
+    private String validCallbackRequestJson() throws Exception {
+        Map<String, Object> caseData = new HashMap<>();
+        caseData.put("id", TEST_CASE_ID);
+        caseData.put("reviewDate", "2030-01-01");
+        caseData.put("existingField", "existingValue");
+
+        CallbackRequest callbackRequest = CallbackRequest.builder()
+            .eventId("request-further-information")
+            .caseDetails(CaseDetails.builder()
+                             .id(TEST_CASE_ID)
+                             .state("AWAITING_INFORMATION")
+                             .data(caseData)
+                             .build())
+            .caseDetailsBefore(CaseDetails.builder()
+                                   .id(TEST_CASE_ID)
+                                   .state("CASE_ISSUED")
+                                   .data(new HashMap<>(caseData))
+                                   .build())
+            .build();
+
+        return objectMapper.writeValueAsString(callbackRequest);
+    }
+
+    private Map<String, Object> submittedCaseData() {
+        Map<String, Object> caseData = new HashMap<>();
+        caseData.put("id", TEST_CASE_ID);
+        caseData.put("applicantName", "John Doe");
+        caseData.put("respondentName", "Jane Doe");
+        caseData.put(CASE_STATUS, CaseStatus.builder().state("Awaiting information").build());
+        return caseData;
+    }
+}