From 8990b1caf985a66a64638300224e14350ac1b86b Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Mon, 6 Nov 2023 14:53:31 -0800
Subject: [PATCH 01/16] Avoid configuration property namespacing issues

---
 .../DisabledFlowPropertyConfiguration.java    |  2 +-
 ...LockedSubmissionPropertyConfiguration.java | 40 +++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java

diff --git a/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java b/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java
index d4c77fbea..4bbc5fb70 100644
--- a/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java
+++ b/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java
@@ -12,7 +12,7 @@
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
-@ConfigurationProperties(prefix = "form-flow")
+@ConfigurationProperties(prefix = "form-flow.disabled-flows")
 @Getter
 @Setter
 public class DisabledFlowPropertyConfiguration {
diff --git a/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java b/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java
new file mode 100644
index 000000000..ccb25871e
--- /dev/null
+++ b/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java
@@ -0,0 +1,40 @@
+package formflow.library.config;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "form-flow.lock-after-submitted")
+@Getter
+@Setter
+public class LockedSubmissionPropertyConfiguration {
+  private List<Map<String, String>> lockAfterSubmitted = new ArrayList<>();
+
+
+  /**
+   * Checks if the flow with flowName is disabled.
+   * @param flowName the name of the flow to check.
+   * @return true if the flow is disabled, false otherwise.
+   */
+  public boolean isFlowSubmissionLocked(String flowName) {
+    return this.lockAfterSubmitted.stream().anyMatch(flow -> flow.get("flow").equals(flowName));
+  }
+
+  /**
+   * Gets the static redirect page for a disabled flow.
+   * @param flowName the name of the flow to check.
+   * @return the static redirect page for the flow if disabled flows are configured and the flow is disabled.
+   */
+  public String getRedirectForSubmissionLockedFlow(String flowName) {
+    return lockAfterSubmitted.stream()
+        .filter(flow -> flow.get("flow").equals(flowName))
+        .map(flow -> flow.getOrDefault("submissionLockedRedirect", ""))
+        .findFirst()
+        .orElse(null);
+  }
+}

From 1a88e3a74870fddc5c2b78f24e1f70ee6993f402 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Tue, 7 Nov 2023 18:05:05 -0800
Subject: [PATCH 02/16] Consolidate DisabedFlowPropertyConfiguration to
 FormFlowConfigurationProperties

[#186001975]
---
 .../DisabledFlowInterceptorConfiguration.java | 10 ++---
 .../config/FlowsConfigurationFactory.java     | 13 +++---
 .../FlowsConfigurationFactoryConfig.java      |  8 ++--
 ...a => FormFlowConfigurationProperties.java} | 30 +++++++++++---
 ...LockedSubmissionPropertyConfiguration.java | 40 -------------------
 .../interceptors/DisabledFlowInterceptor.java | 15 +++----
 .../interceptors/SpyInterceptorConfig.java    |  6 +--
 7 files changed, 46 insertions(+), 76 deletions(-)
 rename src/main/java/formflow/library/config/{DisabledFlowPropertyConfiguration.java => FormFlowConfigurationProperties.java} (51%)
 delete mode 100644 src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java

diff --git a/src/main/java/formflow/library/config/DisabledFlowInterceptorConfiguration.java b/src/main/java/formflow/library/config/DisabledFlowInterceptorConfiguration.java
index d40c1229e..1d94ae2d1 100644
--- a/src/main/java/formflow/library/config/DisabledFlowInterceptorConfiguration.java
+++ b/src/main/java/formflow/library/config/DisabledFlowInterceptorConfiguration.java
@@ -6,8 +6,6 @@
 import formflow.library.interceptors.DisabledFlowInterceptor;
 import java.util.List;
 
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@@ -18,10 +16,10 @@
 @Configuration
 public class DisabledFlowInterceptorConfiguration implements WebMvcConfigurer {
   
-  DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration;
+  FormFlowConfigurationProperties formFlowConfigurationProperties;
   
-  public DisabledFlowInterceptorConfiguration(DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration) {
-    this.disabledFlowPropertyConfiguration = disabledFlowPropertyConfiguration;
+  public DisabledFlowInterceptorConfiguration(FormFlowConfigurationProperties formFlowConfigurationProperties) {
+    this.formFlowConfigurationProperties = formFlowConfigurationProperties;
   }
   
   /**
@@ -30,7 +28,7 @@ public DisabledFlowInterceptorConfiguration(DisabledFlowPropertyConfiguration di
    */
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
-    registry.addInterceptor(new DisabledFlowInterceptor(disabledFlowPropertyConfiguration))
+    registry.addInterceptor(new DisabledFlowInterceptor(formFlowConfigurationProperties))
         .addPathPatterns(List.of(PATH_FORMAT));
   }
 }
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index 95129fc59..27efdd740 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -3,11 +3,8 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.Flow;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.io.ClassPathResource;
 import org.yaml.snakeyaml.DumperOptions;
@@ -25,15 +22,15 @@ public class FlowsConfigurationFactory implements FactoryBean<List<FlowConfigura
   @Value("${form-flow.path:flows-config.yaml}")
   String configPath;
   
-  DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration;
+  FormFlowConfigurationProperties formFlowConfigurationProperties;
 
 
   FlowsConfigurationFactory() {
-    this.disabledFlowPropertyConfiguration = null;
+    this.formFlowConfigurationProperties = null;
   }
 
-  FlowsConfigurationFactory(DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration) {
-    this.disabledFlowPropertyConfiguration = disabledFlowPropertyConfiguration;
+  FlowsConfigurationFactory(FormFlowConfigurationProperties formFlowConfigurationProperties) {
+    this.formFlowConfigurationProperties = formFlowConfigurationProperties;
   }
 
   /**
@@ -60,7 +57,7 @@ public List<FlowConfiguration> getObject() throws IOException {
       Iterable<Object> appConfigsIterable = yaml.loadAll(classPathResource.getInputStream());
       appConfigsIterable.forEach(appConfig -> {
         FlowConfiguration flowConfig = (FlowConfiguration) appConfig;
-        if (disabledFlowPropertyConfiguration == null || !disabledFlowPropertyConfiguration.isFlowDisabled(flowConfig.getName())) {
+        if (formFlowConfigurationProperties == null || !formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName())) {
           appConfigs.add(flowConfig);
         }
         
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
index 1799c4056..a2481beb5 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
@@ -3,12 +3,10 @@
 import java.io.IOException;
 
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Factory for FlowsConfiguration configuration.
@@ -17,7 +15,7 @@
 public class FlowsConfigurationFactoryConfig {
 
   @Autowired(required = false)
-  DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration;
+  FormFlowConfigurationProperties formFlowConfigurationProperties;
 
 
   /**
@@ -27,10 +25,10 @@ public class FlowsConfigurationFactoryConfig {
    */
   @Bean
   public FlowsConfigurationFactory flowsConfigurationFactory() {
-    if (this.disabledFlowPropertyConfiguration == null) {
+    if (this.formFlowConfigurationProperties == null) {
       return new FlowsConfigurationFactory();
     }
-    return new FlowsConfigurationFactory(disabledFlowPropertyConfiguration);
+    return new FlowsConfigurationFactory(formFlowConfigurationProperties);
   }
 
   /**
diff --git a/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
similarity index 51%
rename from src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java
rename to src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
index 4bbc5fb70..65a08b2c5 100644
--- a/src/main/java/formflow/library/config/DisabledFlowPropertyConfiguration.java
+++ b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
@@ -3,20 +3,18 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import lombok.Getter;
 import lombok.Setter;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
-@ConfigurationProperties(prefix = "form-flow.disabled-flows")
+@ConfigurationProperties(prefix = "form-flow")
 @Getter
 @Setter
-public class DisabledFlowPropertyConfiguration {
+public class FormFlowConfigurationProperties {
   private List<Map<String, String>> disabledFlows = new ArrayList<>();
+  private List<Map<String, String>  > lockAfterSubmitted = new ArrayList<>();
 
 
   /**
@@ -40,4 +38,26 @@ public String getDisabledFlowRedirect(String flowName) {
         .findFirst()
         .orElse(null);
   }
+
+  /**
+   * Checks if the Submission for the flow with flowName should be locked, preventing further updates after it has been submitted.
+   * @param flowName the name of the flow to check.
+   * @return true if the Submission should be locked for the given flow, false otherwise.
+   */
+  public boolean isSubmissionLockedForFlow(String flowName) {
+    return this.lockAfterSubmitted.stream().anyMatch(flow -> flow.get("flow").equals(flowName));
+  }
+
+  /**
+   * Gets the redirect screen designated for the given flow with a locked submission.
+   * @param flowName the name of the flow to check.
+   * @return the screen to redirect to if the submission is locked for the given flow.
+   */
+  public String getRedirectForFlowWithLockedSubmission(String flowName) {
+    return lockAfterSubmitted.stream()
+        .filter(flow -> flow.get("flow").equals(flowName))
+        .map(flow -> flow.getOrDefault("submissionLockedRedirect", ""))
+        .findFirst()
+        .orElse(null);
+  }
 }
diff --git a/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java b/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java
deleted file mode 100644
index ccb25871e..000000000
--- a/src/main/java/formflow/library/config/LockedSubmissionPropertyConfiguration.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package formflow.library.config;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import lombok.Getter;
-import lombok.Setter;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "form-flow.lock-after-submitted")
-@Getter
-@Setter
-public class LockedSubmissionPropertyConfiguration {
-  private List<Map<String, String>> lockAfterSubmitted = new ArrayList<>();
-
-
-  /**
-   * Checks if the flow with flowName is disabled.
-   * @param flowName the name of the flow to check.
-   * @return true if the flow is disabled, false otherwise.
-   */
-  public boolean isFlowSubmissionLocked(String flowName) {
-    return this.lockAfterSubmitted.stream().anyMatch(flow -> flow.get("flow").equals(flowName));
-  }
-
-  /**
-   * Gets the static redirect page for a disabled flow.
-   * @param flowName the name of the flow to check.
-   * @return the static redirect page for the flow if disabled flows are configured and the flow is disabled.
-   */
-  public String getRedirectForSubmissionLockedFlow(String flowName) {
-    return lockAfterSubmitted.stream()
-        .filter(flow -> flow.get("flow").equals(flowName))
-        .map(flow -> flow.getOrDefault("submissionLockedRedirect", ""))
-        .findFirst()
-        .orElse(null);
-  }
-}
diff --git a/src/main/java/formflow/library/interceptors/DisabledFlowInterceptor.java b/src/main/java/formflow/library/interceptors/DisabledFlowInterceptor.java
index c371c55b8..8e19c2ae2 100644
--- a/src/main/java/formflow/library/interceptors/DisabledFlowInterceptor.java
+++ b/src/main/java/formflow/library/interceptors/DisabledFlowInterceptor.java
@@ -1,16 +1,13 @@
 package formflow.library.interceptors;
 
 import formflow.library.ScreenController;
-import formflow.library.config.DisabledFlowPropertyConfiguration;
-import formflow.library.exceptions.LandmarkNotSetException;
+import formflow.library.config.FormFlowConfigurationProperties;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import java.io.IOException;
-import java.util.List;
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.core.Ordered;
 import org.springframework.stereotype.Component;
 import org.springframework.util.AntPathMatcher;
@@ -24,10 +21,10 @@
 public class DisabledFlowInterceptor implements HandlerInterceptor, Ordered {
   public static final String PATH_FORMAT = ScreenController.FLOW + "/" + ScreenController.FLOW_SCREEN_PATH;
 
-  DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration;
+  FormFlowConfigurationProperties formFlowConfigurationProperties;
   
-  public DisabledFlowInterceptor(DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration) {
-    this.disabledFlowPropertyConfiguration = disabledFlowPropertyConfiguration;
+  public DisabledFlowInterceptor(FormFlowConfigurationProperties formFlowConfigurationProperties) {
+    this.formFlowConfigurationProperties = formFlowConfigurationProperties;
   }
 
   /**
@@ -44,8 +41,8 @@ public DisabledFlowInterceptor(DisabledFlowPropertyConfiguration disabledFlowPro
   public boolean preHandle(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler) {
     Map<String, String> parsedUrl = new AntPathMatcher().extractUriTemplateVariables(PATH_FORMAT, request.getRequestURI());
     String requestedFlow = parsedUrl.get("flow");
-    if (disabledFlowPropertyConfiguration.isFlowDisabled(requestedFlow)) {
-      String staticRedirectPage = disabledFlowPropertyConfiguration.getDisabledFlowRedirect(requestedFlow);
+    if (formFlowConfigurationProperties.isFlowDisabled(requestedFlow)) {
+      String staticRedirectPage = formFlowConfigurationProperties.getDisabledFlowRedirect(requestedFlow);
       if (staticRedirectPage == null || staticRedirectPage.isEmpty()) {
         log.warn("Flow %s is disabled but no static redirect page is configured. Going home instead.".formatted(requestedFlow));
         staticRedirectPage = "/disabledFeature";
diff --git a/src/test/java/formflow/library/interceptors/SpyInterceptorConfig.java b/src/test/java/formflow/library/interceptors/SpyInterceptorConfig.java
index 17cf67f34..a54be1006 100644
--- a/src/test/java/formflow/library/interceptors/SpyInterceptorConfig.java
+++ b/src/test/java/formflow/library/interceptors/SpyInterceptorConfig.java
@@ -1,6 +1,6 @@
 package formflow.library.interceptors;
 
-import formflow.library.config.DisabledFlowPropertyConfiguration;
+import formflow.library.config.FormFlowConfigurationProperties;
 import formflow.library.config.FlowConfiguration;
 import java.util.List;
 import org.mockito.Mockito;
@@ -19,7 +19,7 @@ public class SpyInterceptorConfig implements WebMvcConfigurer {
     private List<FlowConfiguration> flowConfigurations;
     
     @Autowired
-    private DisabledFlowPropertyConfiguration disabledFlowPropertyConfiguration;
+    private FormFlowConfigurationProperties formFlowConfigurationProperties;
 
     @Bean
     @Primary
@@ -36,7 +36,7 @@ public SessionContinuityInterceptor dataRequiredInterceptor() {
     @Bean
     @Primary
     public DisabledFlowInterceptor disabledFlowInterceptor() {
-        return Mockito.spy(new DisabledFlowInterceptor(disabledFlowPropertyConfiguration));
+        return Mockito.spy(new DisabledFlowInterceptor(formFlowConfigurationProperties));
     }
 
     @Override

From 8d15387b4b818ab7af2802430b913fb41c20240e Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Tue, 7 Nov 2023 18:05:31 -0800
Subject: [PATCH 03/16] Create test for locked submission in a given flow

[#186001975]
---
 .../LockedSubmissionRedirectTest.java         | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java

diff --git a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
new file mode 100644
index 000000000..b994402e3
--- /dev/null
+++ b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
@@ -0,0 +1,88 @@
+package formflow.library.controllers;
+
+import static formflow.library.FormFlowController.SUBMISSION_MAP_NAME;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import formflow.library.data.Submission;
+import formflow.library.utilities.AbstractMockMvcTest;
+import formflow.library.utilities.FormScreen;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.util.LinkedMultiValueMap;
+
+@SpringBootTest(properties = {"form-flow.path=flows-config/test-flow.yaml"})
+@TestPropertySource(properties = {
+    "form-flow.lock-after-submitted[0].flow=testFlow",
+    "form-flow.lock-after-submitted[0].submissionLockedRedirectPage=success"
+//    "form-flow.disabled-flows[1].flow=otherTestFlow",
+//    "form-flow.disabled-flows[1].staticRedirectPage=/disabledFeature",
+})
+public class LockedSubmissionRedirectTest extends AbstractMockMvcTest {
+
+  @BeforeEach
+  public void setUp() throws Exception {
+    UUID submissionUUID = UUID.randomUUID();
+    submission = Submission.builder().id(submissionUUID).urlParams(new HashMap<>()).inputData(new HashMap<>()).build();
+    // this setups flow info in the session to get passed along later on.
+    setFlowInfoInSession(session, "testFlow", submission.getId());
+    super.setUp();
+  }
+
+  @Test
+  public void shouldRedirectToConfiguredScreenWhenDisabledFlowInterceptionIsEnabled() throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/inputs")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInput", List.of("firstFlowTextInputValue"),
+            "numberInput", List.of("10"))))
+    );
+    
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+    
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+    
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    // Assert that we are redirected to the configured screen when we try to go back into the flow when the submission should be locked
+    mockMvc.perform(get("/flow/testFlow/inputs")
+        .session(session))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+  }
+}

From ca1ce8fdfbc1f0d46d08676c00ef84f99328adda Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Tue, 7 Nov 2023 18:05:48 -0800
Subject: [PATCH 04/16] WIP - Beginning implementation

[#186001975]
---
 .../java/formflow/library/FileController.java   |  4 +++-
 .../formflow/library/FormFlowController.java    | 17 ++++++++++++++++-
 .../java/formflow/library/PdfController.java    |  6 ++++--
 .../java/formflow/library/ScreenController.java |  4 +++-
 .../library/controllers/PdfControllerTest.java  |  7 ++++++-
 .../testFlow/pageWithCustomSubmitButton.html    |  2 +-
 6 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index 859c81fcd..f93aff1bf 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -3,6 +3,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.io.Files;
 import formflow.library.config.FlowConfiguration;
+import formflow.library.config.FormFlowConfigurationProperties;
 import formflow.library.data.Submission;
 import formflow.library.data.SubmissionRepositoryService;
 import formflow.library.data.UserFile;
@@ -74,11 +75,12 @@ public FileController(
       FileVirusScanner fileVirusScanner,
       SubmissionRepositoryService submissionRepositoryService,
       List<FlowConfiguration> flowConfigurations,
+      FormFlowConfigurationProperties formFlowConfigurationProperties,
       MessageSource messageSource,
       FileValidationService fileValidationService,
       @Value("${form-flow.uploads.max-files:20}") Integer maxFiles,
       @Value("${form-flow.uploads.virus-scanning.block-if-unreachable:false}") boolean blockIfClammitUnreachable) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations);
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
     this.cloudFileRepository = cloudFileRepository;
     this.messageSource = messageSource;
     this.fileValidationService = fileValidationService;
diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index 7fc311196..5f648bc6a 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -1,6 +1,7 @@
 package formflow.library;
 
 import formflow.library.config.FlowConfiguration;
+import formflow.library.config.FormFlowConfigurationProperties;
 import formflow.library.data.Submission;
 import formflow.library.data.SubmissionRepositoryService;
 import formflow.library.data.UserFileRepositoryService;
@@ -22,14 +23,17 @@ public abstract class FormFlowController {
   protected final UserFileRepositoryService userFileRepositoryService;
 
   protected final List<FlowConfiguration> flowConfigurations;
+  
+  protected final FormFlowConfigurationProperties formFlowConfigurationProperties;
 
   public static final String SUBMISSION_MAP_NAME = "submissionMap";
 
   FormFlowController(SubmissionRepositoryService submissionRepositoryService, UserFileRepositoryService userFileRepositoryService,
-      List<FlowConfiguration> flowConfigurations) {
+      List<FlowConfiguration> flowConfigurations, FormFlowConfigurationProperties formFlowConfigurationProperties) {
     this.submissionRepositoryService = submissionRepositoryService;
     this.userFileRepositoryService = userFileRepositoryService;
     this.flowConfigurations = flowConfigurations;
+    this.formFlowConfigurationProperties = formFlowConfigurationProperties;
   }
 
   protected Submission saveToRepository(Submission submission) {
@@ -167,4 +171,15 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
     submissionMap.put(flow, id);
     session.setAttribute(SUBMISSION_MAP_NAME, submissionMap);
   }
+
+  /**
+   * Checks if the Submission for the flow with flowName should be locked, preventing further updates after it has been submitted.
+   * @param flowName the name of the flow to check.
+   * @param submission the Submission to check.
+   * @return true if the Submission is configured to be locked for a given flow and the Submission's submittedAt value is not null,
+   * false otherwise.
+   */
+  public boolean shouldRedirectDueToLockedSubmission(String flowName, Submission submission) {
+    return this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
+  }
 }
diff --git a/src/main/java/formflow/library/PdfController.java b/src/main/java/formflow/library/PdfController.java
index 41a299bbb..c8645a85f 100644
--- a/src/main/java/formflow/library/PdfController.java
+++ b/src/main/java/formflow/library/PdfController.java
@@ -1,6 +1,7 @@
 package formflow.library;
 
 import formflow.library.config.FlowConfiguration;
+import formflow.library.config.FormFlowConfigurationProperties;
 import formflow.library.data.Submission;
 import formflow.library.data.SubmissionRepositoryService;
 import formflow.library.data.UserFileRepositoryService;
@@ -36,8 +37,9 @@ public class PdfController extends FormFlowController {
   public PdfController(MessageSource messageSource, PdfService pdfService,
       SubmissionRepositoryService submissionRepositoryService,
       UserFileRepositoryService userFileRepositoryService,
-      List<FlowConfiguration> flowConfigurations) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations);
+      List<FlowConfiguration> flowConfigurations,
+      FormFlowConfigurationProperties formFlowConfigurationProperties) {
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
     this.messageSource = messageSource;
     this.pdfService = pdfService;
   }
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index 374bc7bf0..f22225747 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -6,6 +6,7 @@
 import formflow.library.config.ActionManager;
 import formflow.library.config.ConditionManager;
 import formflow.library.config.FlowConfiguration;
+import formflow.library.config.FormFlowConfigurationProperties;
 import formflow.library.config.NextScreen;
 import formflow.library.config.ScreenNavigationConfiguration;
 import formflow.library.config.SubflowConfiguration;
@@ -67,10 +68,11 @@ public ScreenController(
       SubmissionRepositoryService submissionRepositoryService,
       ValidationService validationService,
       AddressValidationService addressValidationService,
+      FormFlowConfigurationProperties formFlowConfigurationProperties,
       ConditionManager conditionManager,
       ActionManager actionManager,
       FileValidationService fileValidationService) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations);
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
     this.validationService = validationService;
     this.addressValidationService = addressValidationService;
     this.conditionManager = conditionManager;
diff --git a/src/test/java/formflow/library/controllers/PdfControllerTest.java b/src/test/java/formflow/library/controllers/PdfControllerTest.java
index 77952efa1..5b5dfe8bd 100644
--- a/src/test/java/formflow/library/controllers/PdfControllerTest.java
+++ b/src/test/java/formflow/library/controllers/PdfControllerTest.java
@@ -16,6 +16,7 @@
 import formflow.library.data.UserFileRepositoryService;
 import formflow.library.pdf.PdfService;
 import formflow.library.utilities.AbstractMockMvcTest;
+import formflow.library.config.FormFlowConfigurationProperties;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
@@ -40,6 +41,10 @@ public class PdfControllerTest extends AbstractMockMvcTest {
 
   @MockBean
   private UserFileRepositoryService userFileRepositoryService;
+  
+  @MockBean
+  private FormFlowConfigurationProperties formFlowConfigurationProperties;
+  
   private byte[] filledPdfByteArray;
 
   private final String flowName = "testFlow";
@@ -59,7 +64,7 @@ public void setUp() throws Exception {
     );
 
     PdfController pdfController = new PdfController(messageSource, pdfService, submissionRepositoryService,
-        userFileRepositoryService, flowConfigurations);
+        userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
     mockMvc = MockMvcBuilders.standaloneSetup(pdfController).build();
 
     submission = Submission.builder()
diff --git a/src/test/resources/templates/testFlow/pageWithCustomSubmitButton.html b/src/test/resources/templates/testFlow/pageWithCustomSubmitButton.html
index a37013a7b..2d1d7e8c6 100644
--- a/src/test/resources/templates/testFlow/pageWithCustomSubmitButton.html
+++ b/src/test/resources/templates/testFlow/pageWithCustomSubmitButton.html
@@ -10,7 +10,7 @@
         <th:block
             th:replace="~{fragments/cardHeader :: cardHeader(header='Page with optional validation')}"/>
         <th:block
-            th:replace="~{fragments/form :: form(action=${formAction}, content=~{::formContent})}">
+            th:replace="~{fragments/form :: form(action=${formAction + '/submit'}, content=~{::formContent})}">
           <th:block th:ref="formContent">
             <div class="form-card__footer">
               <th:block th:replace="~{fragments/inputs/submitButton :: submitButton(

From 19d38f4ec93cf0e39b724e46b37c62d3467bf5dd Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Mon, 13 Nov 2023 16:30:13 -0800
Subject: [PATCH 05/16] WIP - Implement for POST and add default message on
 redirect

[#186001975]
---
 .../java/formflow/library/FileController.java |  5 +-
 .../formflow/library/FormFlowController.java  | 17 ++++-
 .../java/formflow/library/PdfController.java  |  5 +-
 .../formflow/library/ScreenController.java    | 42 ++++++++++---
 .../FormFlowConfigurationProperties.java      |  4 +-
 .../library/config/LandmarkConfiguration.java |  2 +
 .../resources/messages-form-flow.properties   |  3 +
 .../LockedSubmissionRedirectTest.java         | 63 ++++++++++++++++++-
 .../resources/flows-config/test-flow.yaml     |  4 ++
 9 files changed, 124 insertions(+), 21 deletions(-)

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index f93aff1bf..9c084a554 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -56,7 +56,6 @@ public class FileController extends FormFlowController {
   private final CloudFileRepository cloudFileRepository;
   private final Boolean blockIfClammitUnreachable;
   private final FileVirusScanner fileVirusScanner;
-  private final MessageSource messageSource;
   private final FileValidationService fileValidationService;
   private final String SESSION_USERFILES_KEY = "userFiles";
   private final Integer maxFiles;
@@ -80,9 +79,9 @@ public FileController(
       FileValidationService fileValidationService,
       @Value("${form-flow.uploads.max-files:20}") Integer maxFiles,
       @Value("${form-flow.uploads.virus-scanning.block-if-unreachable:false}") boolean blockIfClammitUnreachable) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties,
+        messageSource);
     this.cloudFileRepository = cloudFileRepository;
-    this.messageSource = messageSource;
     this.fileValidationService = fileValidationService;
     this.maxFiles = maxFiles;
     this.fileVirusScanner = fileVirusScanner;
diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index 5f648bc6a..551fad357 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -6,12 +6,14 @@
 import formflow.library.data.SubmissionRepositoryService;
 import formflow.library.data.UserFileRepositoryService;
 import jakarta.servlet.http.HttpSession;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.Map;
 import java.util.HashMap;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.MessageSource;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.server.ResponseStatusException;
 
@@ -26,14 +28,18 @@ public abstract class FormFlowController {
   
   protected final FormFlowConfigurationProperties formFlowConfigurationProperties;
 
+  protected final MessageSource messageSource;
+
   public static final String SUBMISSION_MAP_NAME = "submissionMap";
 
   FormFlowController(SubmissionRepositoryService submissionRepositoryService, UserFileRepositoryService userFileRepositoryService,
-      List<FlowConfiguration> flowConfigurations, FormFlowConfigurationProperties formFlowConfigurationProperties) {
+      List<FlowConfiguration> flowConfigurations, FormFlowConfigurationProperties formFlowConfigurationProperties,
+      MessageSource messageSource) {
     this.submissionRepositoryService = submissionRepositoryService;
     this.userFileRepositoryService = userFileRepositoryService;
     this.flowConfigurations = flowConfigurations;
     this.formFlowConfigurationProperties = formFlowConfigurationProperties;
+    this.messageSource = messageSource;
   }
 
   protected Submission saveToRepository(Submission submission) {
@@ -179,7 +185,12 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
    * @return true if the Submission is configured to be locked for a given flow and the Submission's submittedAt value is not null,
    * false otherwise.
    */
-  public boolean shouldRedirectDueToLockedSubmission(String flowName, Submission submission) {
-    return this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
+  public boolean shouldRedirectDueToLockedSubmission(String flowName, String screen, Submission submission) {
+    // TODO what if this is null?
+    ArrayList<String> afterSubmitPages = getFlowConfigurationByName(flowName).getLandmarks().getAfterSubmitPages();
+    
+    return this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName) && 
+        submission.getSubmittedAt() != null &&
+        !afterSubmitPages.contains(screen);
   }
 }
diff --git a/src/main/java/formflow/library/PdfController.java b/src/main/java/formflow/library/PdfController.java
index c8645a85f..b3fb2b7ce 100644
--- a/src/main/java/formflow/library/PdfController.java
+++ b/src/main/java/formflow/library/PdfController.java
@@ -31,7 +31,6 @@
 @RequestMapping("/download")
 public class PdfController extends FormFlowController {
 
-  private final MessageSource messageSource;
   private final PdfService pdfService;
 
   public PdfController(MessageSource messageSource, PdfService pdfService,
@@ -39,8 +38,8 @@ public PdfController(MessageSource messageSource, PdfService pdfService,
       UserFileRepositoryService userFileRepositoryService,
       List<FlowConfiguration> flowConfigurations,
       FormFlowConfigurationProperties formFlowConfigurationProperties) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
-    this.messageSource = messageSource;
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties,
+        messageSource);
     this.pdfService = pdfService;
   }
 
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index f22225747..dc4ac99cc 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
@@ -30,6 +31,7 @@
 import org.jetbrains.annotations.Nullable;
 import org.joda.time.DateTime;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.context.MessageSource;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.ModelMap;
@@ -41,6 +43,8 @@
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.server.ResponseStatusException;
 import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+import org.springframework.web.servlet.support.RequestContextUtils;
 import org.springframework.web.servlet.view.RedirectView;
 
 import static formflow.library.inputs.FieldNameMarkers.UNVALIDATED_FIELD_MARKER_VALIDATE_ADDRESS;
@@ -71,8 +75,9 @@ public ScreenController(
       FormFlowConfigurationProperties formFlowConfigurationProperties,
       ConditionManager conditionManager,
       ActionManager actionManager,
-      FileValidationService fileValidationService) {
-    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties);
+      FileValidationService fileValidationService,
+      MessageSource messageSource) {
+    super(submissionRepositoryService, userFileRepositoryService, flowConfigurations, formFlowConfigurationProperties, messageSource);
     this.validationService = validationService;
     this.addressValidationService = addressValidationService;
     this.conditionManager = conditionManager;
@@ -96,13 +101,22 @@ ModelAndView getScreen(
       @PathVariable String screen,
       @RequestParam(required = false) Map<String, String> query_params,
       @RequestParam(value = "uuid", required = false) String uuid,
+      RedirectAttributes redirectAttributes,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      Locale locale
   ) {
     log.info("GET getScreen (url: {}): flow: {}, screen: {}", request.getRequestURI().toLowerCase(), flow, screen);
     // this will ensure that the screen and flow actually exist
     ScreenNavigationConfiguration currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
+    
+    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
+      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+    }
 
     if ((submission.getUrlParams() != null) && (!submission.getUrlParams().isEmpty())) {
       submission.mergeUrlParamsWithData(query_params);
@@ -120,7 +134,7 @@ ModelAndView getScreen(
       actionManager.handleBeforeDisplayAction(currentScreen, submission);
     }
 
-    Map<String, Object> model = createModel(flow, screen, httpSession, submission, null);
+    Map<String, Object> model = createModel(flow, screen, httpSession, submission, null, request);
 
     String formAction = createFormActionString(flow, screen);
     model.put("formAction", formAction);
@@ -156,12 +170,22 @@ ModelAndView postScreen(
       @PathVariable String flow,
       @PathVariable String screen,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      RedirectAttributes redirectAttributes,
+      Locale locale
   ) throws SmartyException, IOException, InterruptedException {
     log.info("POST postScreen (url: {}): flow: {}, screen: {}", request.getRequestURI().toLowerCase(), flow, screen);
     // Checks if screen and flow exist
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
+
+    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
+      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+    }
+    
     FormSubmission formSubmission = new FormSubmission(formData);
     actionManager.handleOnPostAction(currentScreen, formSubmission, submission);
 
@@ -237,7 +261,7 @@ ModelAndView getSubflowScreen(
     }
 
     actionManager.handleBeforeDisplayAction(currentScreen, submission, uuid);
-    Map<String, Object> model = createModel(flow, screen, httpSession, submission, uuid);
+    Map<String, Object> model = createModel(flow, screen, httpSession, submission, uuid, request);
     model.put("formAction", String.format("/flow/%s/%s/%s", flow, screen, uuid));
     return new ModelAndView(String.format("%s/%s", flow, screen), model);
   }
@@ -562,7 +586,7 @@ private String createFormActionString(String flow, String screen) {
   }
 
   private Map<String, Object> createModel(String flow, String screen, HttpSession httpSession, Submission submission,
-      String uuid) {
+      String uuid, HttpServletRequest request) {
     Map<String, Object> model = new HashMap<>();
     FlowConfiguration flowConfig = getFlowConfigurationByName(flow);
     String subflowName = flowConfig.getFlow().get(screen).getSubflow();
@@ -627,6 +651,10 @@ private Map<String, Object> createModel(String flow, String screen, HttpSession
       // We keep "currentSubflowItem" for backwards compatability at this point
       model.put("currentSubflowItem", model.get("fieldData"));
     }
+    
+    if (RequestContextUtils.getInputFlashMap(request) != null) {
+      model.put("lockedSubmissionMessage", RequestContextUtils.getInputFlashMap(request).get("lockedSubmissionMessage"));
+    }
 
     return model;
   }
diff --git a/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
index 65a08b2c5..538951b98 100644
--- a/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
+++ b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
@@ -53,10 +53,10 @@ public boolean isSubmissionLockedForFlow(String flowName) {
    * @param flowName the name of the flow to check.
    * @return the screen to redirect to if the submission is locked for the given flow.
    */
-  public String getRedirectForFlowWithLockedSubmission(String flowName) {
+  public String getLockedSubmissionRedirect(String flowName) {
     return lockAfterSubmitted.stream()
         .filter(flow -> flow.get("flow").equals(flowName))
-        .map(flow -> flow.getOrDefault("submissionLockedRedirect", ""))
+        .map(flow -> flow.getOrDefault("submissionLockedRedirectPage", ""))
         .findFirst()
         .orElse(null);
   }
diff --git a/src/main/java/formflow/library/config/LandmarkConfiguration.java b/src/main/java/formflow/library/config/LandmarkConfiguration.java
index 488b0b98a..06861bb1a 100644
--- a/src/main/java/formflow/library/config/LandmarkConfiguration.java
+++ b/src/main/java/formflow/library/config/LandmarkConfiguration.java
@@ -1,5 +1,6 @@
 package formflow.library.config;
 
+import java.util.ArrayList;
 import lombok.Data;
 
 /**
@@ -8,4 +9,5 @@
 @Data
 public class LandmarkConfiguration {
   String firstScreen;
+  ArrayList<String> afterSubmitPages;
 }
diff --git a/src/main/resources/messages-form-flow.properties b/src/main/resources/messages-form-flow.properties
index 912a8b904..450fae8e7 100644
--- a/src/main/resources/messages-form-flow.properties
+++ b/src/main/resources/messages-form-flow.properties
@@ -22,6 +22,7 @@ general.files.add-your-files=Add your files
 general.files.file-added.one=1 file added
 general.files.file-added.other=files added
 general.files.uploaded-documents=Uploaded documents
+general.locked-submission=You've already submitted this application. To protect your data, we can't let you go back at this time.
 #
 address-validation.check-your-address=Check your address
 address-validation.header.make-sure-your-address-is-correct=Make sure your address is correct
@@ -122,3 +123,5 @@ language-preferences.link-text.vi=Ti?ng Vi?t
 disabled-feature.header=Sorry, that feature is currently unavailable
 disabled-feature.subtext=If you believe this is a mistake or need additional support, please try again later.
 disabled-feature.return=Return to the homepage
+
+
diff --git a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
index b994402e3..df8a11b54 100644
--- a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
+++ b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
@@ -28,8 +28,6 @@
 @TestPropertySource(properties = {
     "form-flow.lock-after-submitted[0].flow=testFlow",
     "form-flow.lock-after-submitted[0].submissionLockedRedirectPage=success"
-//    "form-flow.disabled-flows[1].flow=otherTestFlow",
-//    "form-flow.disabled-flows[1].staticRedirectPage=/disabledFeature",
 })
 public class LockedSubmissionRedirectTest extends AbstractMockMvcTest {
 
@@ -43,7 +41,7 @@ public void setUp() throws Exception {
   }
 
   @Test
-  public void shouldRedirectToConfiguredScreenWhenDisabledFlowInterceptionIsEnabled() throws Exception {
+  public void shouldRedirectToConfiguredScreenWhenAFlowsSubmissionIsConfiguredToLockAfterSubmitted() throws Exception {
     // Make an initial post to create the submission and give it some data
     mockMvc.perform(post("/flow/testFlow/inputs")
         .session(session)
@@ -85,4 +83,63 @@ public void shouldRedirectToConfiguredScreenWhenDisabledFlowInterceptionIsEnable
         .andExpect(status().is3xxRedirection())
         .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
   }
+  
+  @Test
+  void shouldRedirectToConfiguredScreenWhenPostingDataToAFlowThatHasBeenConfiguredToLockAfterBeingSubmittedWithoutUpdatingSubmissionObject()
+      throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/inputs")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInput", List.of("firstFlowTextInputValue"),
+            "numberInput", List.of("10"))))
+    );
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    // Post again and assert that the submission is not updated
+    mockMvc.perform(post("/flow/testFlow/inputs")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInput", List.of("newValue"),
+            "numberInput", List.of("333"),
+            "moneyInput", List.of("444"))))
+    );
+
+    Optional<Submission> testFlowSubmissionAfterAttemptingToPostAfterSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getSubmittedAt()).isNotNull();
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData().get("textInput")).isEqualTo("firstFlowTextInputValue");
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData().get("numberInput")).isEqualTo("10");
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData().get("moneyInput")).isNull();
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData().equals(testFlowSubmissionAfterBeingSubmitted.get().getInputData())).isTrue();
+  }
+  
+  // TODO create tests for GET and POST in subflows
+  
 }
diff --git a/src/test/resources/flows-config/test-flow.yaml b/src/test/resources/flows-config/test-flow.yaml
index c8dad20a5..37f77b2f2 100644
--- a/src/test/resources/flows-config/test-flow.yaml
+++ b/src/test/resources/flows-config/test-flow.yaml
@@ -49,6 +49,10 @@ subflows:
     iterationStartScreen: subflowAddItem
     reviewScreen: testReviewScreen
     deleteConfirmationScreen: testDeleteConfirmationScreen
+landmarks:
+  firstScreen: inputs
+  afterSubmitPages:
+    - success
 ---
 name: otherTestFlow
 flow:

From a032a5dc32ae04090f188dd54c3cf7441b6e94c9 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Tue, 14 Nov 2023 17:10:33 -0800
Subject: [PATCH 06/16] WIP Adding more tests and implementations to make them
 pass

[#186001975]

Co-authored-by: Cypress Borg <cborg@codeforamerica.org>
---
 .../formflow/library/FormFlowController.java  |  39 +++--
 .../formflow/library/ScreenController.java    |  24 ++-
 .../FormFlowConfigurationProperties.java      |   4 +-
 .../LockedSubmissionRedirectTest.java         | 155 +++++++++++++++++-
 4 files changed, 203 insertions(+), 19 deletions(-)

diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index 551fad357..f259ace3d 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -179,18 +179,37 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
   }
 
   /**
-   * Checks if the Submission for the flow with flowName should be locked, preventing further updates after it has been submitted.
-   * @param flowName the name of the flow to check.
-   * @param submission the Submission to check.
-   * @return true if the Submission is configured to be locked for a given flow and the Submission's submittedAt value is not null,
-   * false otherwise.
+   * Determines if the user should be redirected due to a locked submission.
+   *
+   * @param flowName     The name of the flow.
+   * @param screen       The current screen name.
+   * @param submission   The submission object.
+   * @return true if the user should be redirected, false otherwise.
    */
   public boolean shouldRedirectDueToLockedSubmission(String flowName, String screen, Submission submission) {
-    // TODO what if this is null?
-    ArrayList<String> afterSubmitPages = getFlowConfigurationByName(flowName).getLandmarks().getAfterSubmitPages();
+    FlowConfiguration flowConfig = getFlowConfigurationByName(flowName);
     
-    return this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName) && 
-        submission.getSubmittedAt() != null &&
-        !afterSubmitPages.contains(screen);
+    if (submission == null) {
+      // This should hopefully never happen
+      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "The Submission object was null when checking if the user should be redirected due to a locked submission.");
+    }
+    
+    if (flowConfig == null) {
+      // This should hopefully never happen
+      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "The FlowConfiguration object was null when checking if the user should be redirected due to a locked submission.");
+    }
+
+    List<String> afterSubmitPages = flowConfig.getLandmarks().getAfterSubmitPages();
+    if (afterSubmitPages == null) {
+      
+      // Log error or handle the case where afterSubmitPages is null
+      return false;
+    }
+
+    boolean isSubmissionLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
+    boolean isSubmissionSubmitted = submission.getSubmittedAt() != null;
+    boolean isCurrentScreenAfterSubmit = afterSubmitPages.contains(screen);
+
+    return isSubmissionLocked && isSubmissionSubmitted && !isCurrentScreenAfterSubmit;
   }
 }
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index dc4ac99cc..85667e316 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -242,7 +242,9 @@ ModelAndView getSubflowScreen(
       @PathVariable String screen,
       @PathVariable String uuid,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      RedirectAttributes redirectAttributes,
+      Locale locale
   ) throws ResponseStatusException {
     log.info(
         "GET getSubflowScreen (url: {}): flow: {}, screen: {}, uuid: {}",
@@ -254,6 +256,13 @@ ModelAndView getSubflowScreen(
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = getSubmissionFromSession(httpSession, flow);
 
+    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
+      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+    }
+
     if (submission == null) {
       // we have issues! We should not get here, really.
       log.error("There is no submission associated with request!");
@@ -291,7 +300,9 @@ RedirectView postSubflowScreen(
       @PathVariable String screen,
       @PathVariable String uuid,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      RedirectAttributes redirectAttributes,
+      Locale locale
   ) throws ResponseStatusException, SmartyException, IOException, InterruptedException {
     log.info(
         "POST updateOrCreateIteration (url: {}): flow: {}, screen: {}, uuid: {}",
@@ -299,6 +310,7 @@ RedirectView postSubflowScreen(
         flow,
         screen,
         uuid);
+    
     // Checks to see if flow and screen exist
     ScreenNavigationConfiguration currentScreen = getScreenConfig(flow, screen);
     boolean isNewIteration = uuid.equalsIgnoreCase("new");
@@ -306,6 +318,14 @@ RedirectView postSubflowScreen(
     FormSubmission formSubmission = new FormSubmission(formData);
     String subflowName = currentScreen.getSubflow();
     Submission submission = findOrCreateSubmission(httpSession, flow);
+
+    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
+      return new RedirectView(String.format("/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+    }
+    
     actionManager.handleOnPostAction(currentScreen, formSubmission, submission, iterationUuid);
 
     var errorMessages = validationService.validate(currentScreen, flow, formSubmission, submission);
diff --git a/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
index 538951b98..a210136e8 100644
--- a/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
+++ b/src/main/java/formflow/library/config/FormFlowConfigurationProperties.java
@@ -14,7 +14,7 @@
 @Setter
 public class FormFlowConfigurationProperties {
   private List<Map<String, String>> disabledFlows = new ArrayList<>();
-  private List<Map<String, String>  > lockAfterSubmitted = new ArrayList<>();
+  private List<Map<String, String>> lockAfterSubmitted = new ArrayList<>();
 
 
   /**
@@ -56,7 +56,7 @@ public boolean isSubmissionLockedForFlow(String flowName) {
   public String getLockedSubmissionRedirect(String flowName) {
     return lockAfterSubmitted.stream()
         .filter(flow -> flow.get("flow").equals(flowName))
-        .map(flow -> flow.getOrDefault("submissionLockedRedirectPage", ""))
+        .map(flow -> flow.getOrDefault("redirect", ""))
         .findFirst()
         .orElse(null);
   }
diff --git a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
index df8a11b54..2745caadd 100644
--- a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
+++ b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
@@ -27,7 +27,7 @@
 @SpringBootTest(properties = {"form-flow.path=flows-config/test-flow.yaml"})
 @TestPropertySource(properties = {
     "form-flow.lock-after-submitted[0].flow=testFlow",
-    "form-flow.lock-after-submitted[0].submissionLockedRedirectPage=success"
+    "form-flow.lock-after-submitted[0].redirect=success"
 })
 public class LockedSubmissionRedirectTest extends AbstractMockMvcTest {
 
@@ -41,7 +41,7 @@ public void setUp() throws Exception {
   }
 
   @Test
-  public void shouldRedirectToConfiguredScreenWhenAFlowsSubmissionIsConfiguredToLockAfterSubmitted() throws Exception {
+  public void shouldRedirectWhenAttemptingToGetAPageThatIsNotAllowedForAFlowWithALockedSubmission() throws Exception {
     // Make an initial post to create the submission and give it some data
     mockMvc.perform(post("/flow/testFlow/inputs")
         .session(session)
@@ -128,8 +128,9 @@ void shouldRedirectToConfiguredScreenWhenPostingDataToAFlowThatHasBeenConfigured
         .params(new LinkedMultiValueMap<>(Map.of(
             "textInput", List.of("newValue"),
             "numberInput", List.of("333"),
-            "moneyInput", List.of("444"))))
-    );
+            "moneyInput", List.of("444")))))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
 
     Optional<Submission> testFlowSubmissionAfterAttemptingToPostAfterSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
     assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.isPresent()).isTrue();
@@ -140,6 +141,150 @@ void shouldRedirectToConfiguredScreenWhenPostingDataToAFlowThatHasBeenConfigured
     assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData().equals(testFlowSubmissionAfterBeingSubmitted.get().getInputData())).isTrue();
   }
   
-  // TODO create tests for GET and POST in subflows
+  @Test
+  void shouldRedirectWhenAttemptingToGetAScreenInsideASubflowThatIsNotAllowedForAFlowWithALockedSubmission() throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/new")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInputSubflow", List.of("textInputValue"),
+            "numberInputSubflow", List.of("10"))))
+    );
+    
+    // Get the UUID for the iteration we just created
+    UUID testSubflowLogicUUID = ((Map<String, UUID>) session.getAttribute(SUBMISSION_MAP_NAME)).get("testFlow");
+    Submission submissionBeforeSubflowIsCompleted = submissionRepositoryService.findById(testSubflowLogicUUID).get();
+    List<Map<String, Object>> subflowIterations = (List<Map<String, Object>>) submissionBeforeSubflowIsCompleted.getInputData()
+        .get("testSubflow");
+    String uuidString = (String) subflowIterations.get(0).get("uuid");
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+
+    // Assert that we are redirected to the configured screen when we try to go back into the flow when the submission should be locked
+    mockMvc.perform(get("/flow/testFlow/subflowAddItem/" + uuidString )
+            .session(session))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+    
+    // Assert the same as above but for the /edit endpoint
+    mockMvc.perform(get("/flow/testFlow/subflowAddItem/" + uuidString + "/edit")
+            .session(session))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+  }
   
+  @Test
+  void shouldRedirectToConfiguredScreenWhenPostingSubflowDataToAFlowThatHasBeenConfiguredToLockAfterBeingSubmittedWithoutUpdatingSubmissionObject()
+      throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/new")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInputSubflow", List.of("textInputValue"),
+            "numberInputSubflow", List.of("10"))))
+    );
+
+    // Get the UUID for the iteration we just created
+    UUID testSubflowLogicUUID = ((Map<String, UUID>) session.getAttribute(SUBMISSION_MAP_NAME)).get("testFlow");
+    Submission submissionBeforeSubflowIsCompleted = submissionRepositoryService.findById(testSubflowLogicUUID).get();
+    List<Map<String, Object>> subflowIterationsBeforeSubmit = (List<Map<String, Object>>) submissionBeforeSubflowIsCompleted.getInputData()
+        .get("testSubflow");
+    String uuidString = (String) subflowIterationsBeforeSubmit.get(0).get("uuid");
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+    
+    // Submit the flow, assert we reach the success page
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    // Post again and assert that the submission is not updated and that we are redirected
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/" + uuidString)
+            .session(session)
+            .params(new LinkedMultiValueMap<>(Map.of(
+                "textInputSubflow", List.of("newValue"),
+                "numberInputSubflow", List.of("333"),
+                "moneyInputSubflow", List.of("444")))))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+
+    Optional<Submission> testFlowSubmissionAfterAttemptingToPostAfterSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getSubmittedAt()).isNotNull();
+
+    List<Map<String, Object>> subflowIterationsAfterSubmit = (List<Map<String, Object>>) testFlowSubmissionAfterAttemptingToPostAfterSubmitted.get().getInputData()
+        .get("testSubflow");
+    Map<String, Object> subflowIteration = subflowIterationsAfterSubmit.get(0);
+    assertThat(subflowIteration.get("textInputSubflow")).isEqualTo("textInputValue");
+    assertThat(subflowIteration.get("numberInputSubflow")).isEqualTo("10");
+    assertThat(subflowIteration.get("moneyInputSubflow")).isNull();
+    assertThat(subflowIterationsAfterSubmit.equals(subflowIterationsBeforeSubmit)).isTrue();
+    
+    // Do the same but for the /edit endpoint
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/" + uuidString + "/edit")
+            .session(session)
+            .params(new LinkedMultiValueMap<>(Map.of(
+                "textInputSubflow", List.of("editValue"),
+                "numberInputSubflow", List.of("111"),
+                "moneyInputSubflow", List.of("222")))))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+
+    Optional<Submission> testFlowSubmissionAfterAttemptingToEditAfterSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterAttemptingToEditAfterSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterAttemptingToEditAfterSubmitted.get().getSubmittedAt()).isNotNull();
+    List<Map<String, Object>> subflowIterationsAfterEdit = (List<Map<String, Object>>) testFlowSubmissionAfterAttemptingToEditAfterSubmitted.get().getInputData()
+        .get("testSubflow");
+    Map<String, Object> subflowIterationAfterEdit = subflowIterationsAfterEdit.get(0);
+    assertThat(subflowIterationAfterEdit.get("textInputSubflow")).isEqualTo("textInputValue");
+    assertThat(subflowIterationAfterEdit.get("numberInputSubflow")).isEqualTo("10");
+    assertThat(subflowIterationAfterEdit.get("moneyInputSubflow")).isNull();
+    assertThat(subflowIterationsAfterEdit.equals(subflowIterationsBeforeSubmit)).isTrue();
+  }
 }

From 76b31a9516cc0a8004885f64082b33c4985e8a5c Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Wed, 15 Nov 2023 17:00:44 -0800
Subject: [PATCH 07/16] WIP More tests and Build Time error handling!

[#186001975]

Co-authored-by: Cypress Borg <cborg@codeforamerica.org>
---
 .../java/formflow/library/FileController.java | 13 ++++
 .../config/FlowsConfigurationFactory.java     | 17 +++++
 .../FlowsConfigurationFactoryConfig.java      |  3 +-
 .../exceptions/ConfigurationException.java    | 10 +++
 .../resources/messages-form-flow.properties   |  3 +-
 .../templates/fragments/fileUploader.html     |  2 +-
 .../LockedSubmissionRedirectTest.java         | 74 +++++++++++++++++++
 .../resources/flows-config/test-flow.yaml     |  3 +
 .../templates/testFlow/testUpload.html        | 36 +++++++++
 9 files changed, 158 insertions(+), 3 deletions(-)
 create mode 100644 src/main/java/formflow/library/exceptions/ConfigurationException.java
 create mode 100644 src/test/resources/templates/testFlow/testUpload.html

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index 9c084a554..f54ce21c0 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -17,6 +17,7 @@
 import jakarta.servlet.http.HttpSession;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.net.URI;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -45,7 +46,10 @@
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.reactive.function.client.WebClientResponseException;
 import org.springframework.web.server.ResponseStatusException;
+import org.springframework.web.servlet.ModelAndView;
 import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
 import org.springframework.web.servlet.view.RedirectView;
 
 @Controller
@@ -106,6 +110,7 @@ public ResponseEntity<?> upload(
       @RequestParam("flow") String flow,
       @RequestParam("inputName") String inputName,
       @RequestParam("thumbDataURL") String thumbDataUrl,
+      @RequestParam("screen") String screen,
       HttpSession httpSession,
       HttpServletRequest request,
       Locale locale
@@ -118,6 +123,14 @@ public ResponseEntity<?> upload(
       }
 
       Submission submission = findOrCreateSubmission(httpSession, flow);
+
+      if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+        String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+        log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+        String message = messageSource.getMessage("upload-documents.locked-submission", null, locale);
+        return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
+      }
+      
       UUID userFileId = UUID.randomUUID();
       if (submission.getId() == null) {
         submission.setFlow(flow);
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index 27efdd740..2a5cc477d 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -1,5 +1,8 @@
 package formflow.library.config;
 
+import formflow.library.exceptions.ConfigurationException;
+import formflow.library.exceptions.LandmarkNotSetException;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
@@ -57,10 +60,24 @@ public List<FlowConfiguration> getObject() throws IOException {
       Iterable<Object> appConfigsIterable = yaml.loadAll(classPathResource.getInputStream());
       appConfigsIterable.forEach(appConfig -> {
         FlowConfiguration flowConfig = (FlowConfiguration) appConfig;
+        
         if (formFlowConfigurationProperties == null || !formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName())) {
           appConfigs.add(flowConfig);
         }
         
+        if (formFlowConfigurationProperties != null && formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName())) {
+          if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getFirstScreen() == null) {
+            log.error("You have disabled flow {} but you did not add a landmarks first screen section to it's flow configuration file.", flowConfig.getName());
+            throw new ConfigurationException(String.format("You have disabled flow %s but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName()));
+          }
+        }
+        
+        if (formFlowConfigurationProperties != null && formFlowConfigurationProperties.isSubmissionLockedForFlow(flowConfig.getName())) {
+          if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
+            log.error("You have configured submission locking for flow {} but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName());
+            throw new ConfigurationException(String.format("You have configured submission locking for flow %s but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName()));
+          }
+        }
       });
     } catch (IOException e) {
       log.error("Can't find the flow configuration file: " + configPath, e);
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
index a2481beb5..302dd19df 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
@@ -1,5 +1,6 @@
 package formflow.library.config;
 
+import formflow.library.exceptions.LandmarkNotSetException;
 import java.io.IOException;
 
 import org.springframework.beans.factory.annotation.Autowired;
@@ -37,7 +38,7 @@ public FlowsConfigurationFactory flowsConfigurationFactory() {
    * @return list of flow configuration objects
    */
   @Bean
-  public List<FlowConfiguration> flowsConfiguration() throws IOException {
+  public List<FlowConfiguration> flowsConfiguration() throws IOException, LandmarkNotSetException {
     return flowsConfigurationFactory().getObject();
   }
 }
diff --git a/src/main/java/formflow/library/exceptions/ConfigurationException.java b/src/main/java/formflow/library/exceptions/ConfigurationException.java
new file mode 100644
index 000000000..79dbd8e4f
--- /dev/null
+++ b/src/main/java/formflow/library/exceptions/ConfigurationException.java
@@ -0,0 +1,10 @@
+package formflow.library.exceptions;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+public class ConfigurationException extends RuntimeException {
+    public ConfigurationException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/resources/messages-form-flow.properties b/src/main/resources/messages-form-flow.properties
index 450fae8e7..352e0059d 100644
--- a/src/main/resources/messages-form-flow.properties
+++ b/src/main/resources/messages-form-flow.properties
@@ -44,7 +44,8 @@ upload-documents.error-password-protected=We are unable to process password-prot
 upload-documents.error-could-not-read-file=We could not read the uploaded file. Please try another file.
 upload-documents.error-mime-type=File contents did not match accepted mime types.
 upload-documents.error-virus-found=We are unable to process this file because a virus was detected. Please try another file.
-upload-documents.error-virus-scanner-unavailable=The upload service could not be reached at this time. Please try again later. 
+upload-documents.error-virus-scanner-unavailable=The upload service could not be reached at this time. Please try again later.
+upload-documents.locked-submission=You've already submitted this application. You can no longer upload documents at this time.
 #
 demo.banner-text=<b>This site is for example purposes only</b>
 #
diff --git a/src/main/resources/templates/fragments/fileUploader.html b/src/main/resources/templates/fragments/fileUploader.html
index d197eea90..32c564232 100644
--- a/src/main/resources/templates/fragments/fileUploader.html
+++ b/src/main/resources/templates/fragments/fileUploader.html
@@ -331,7 +331,7 @@
           formData.append("_csrf", csrfToken);
           formData.append("type", file.type);
           formData.append("flow", [[${flow}]]);
-          formData.append("subflow", [[${subflow}]]);
+          formData.append("screen", [[${screen}]]);
           formData.append("inputName", [[${inputName}]]);
           formData.append("thumbDataURL", file.dataURL);
         })
diff --git a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
index 2745caadd..b9fac8559 100644
--- a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
+++ b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
@@ -3,12 +3,17 @@
 import static formflow.library.FormFlowController.SUBMISSION_MAP_NAME;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import formflow.library.data.Submission;
+import formflow.library.data.UserFile;
+import formflow.library.data.UserFileRepositoryService;
 import formflow.library.utilities.AbstractMockMvcTest;
 import formflow.library.utilities.FormScreen;
 import java.util.HashMap;
@@ -20,8 +25,13 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockMultipartFile;
 import org.springframework.test.context.TestPropertySource;
 import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 import org.springframework.util.LinkedMultiValueMap;
 
 @SpringBootTest(properties = {"form-flow.path=flows-config/test-flow.yaml"})
@@ -31,6 +41,9 @@
 })
 public class LockedSubmissionRedirectTest extends AbstractMockMvcTest {
 
+  @MockBean
+  private UserFileRepositoryService userFileRepositoryService;
+
   @BeforeEach
   public void setUp() throws Exception {
     UUID submissionUUID = UUID.randomUUID();
@@ -287,4 +300,65 @@ void shouldRedirectToConfiguredScreenWhenPostingSubflowDataToAFlowThatHasBeenCon
     assertThat(subflowIterationAfterEdit.get("moneyInputSubflow")).isNull();
     assertThat(subflowIterationsAfterEdit.equals(subflowIterationsBeforeSubmit)).isTrue();
   }
+  
+  @Test
+  void shouldErrorWhenAttemptingToUploadFilesToAFlowWithALockedSubmission() throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/inputs")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInput", List.of("firstFlowTextInputValue"),
+            "numberInput", List.of("10"))))
+    );
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    UUID fileId = UUID.randomUUID();
+
+    MockMultipartFile testImage = new MockMultipartFile("file", "someImage.jpg",
+        MediaType.IMAGE_JPEG_VALUE, "test".getBytes());
+
+    when(userFileRepositoryService.save(any())).thenAnswer(invocation -> {
+      UserFile userFile = invocation.getArgument(0);
+      userFile.setFileId(fileId);
+      return userFile;
+    });
+
+    ResultActions resultAfterSubmit = mockMvc.perform(MockMvcRequestBuilders.multipart("/file-upload")
+            .file(testImage)
+            .param("flow", "testFlow")
+            .param("screen", "testUpload")
+            .param("inputName", "testUpload")
+            .param("thumbDataURL", "base64string")
+            .session(session)
+            .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
+        .andExpect(status().is(HttpStatus.BAD_REQUEST.value()));
+    
+    assertThat(resultAfterSubmit.andReturn().getResponse().getContentAsString()).contains("You've already submitted this application. You can no longer upload documents at this time.");
+  }
 }
diff --git a/src/test/resources/flows-config/test-flow.yaml b/src/test/resources/flows-config/test-flow.yaml
index 37f77b2f2..654ceb723 100644
--- a/src/test/resources/flows-config/test-flow.yaml
+++ b/src/test/resources/flows-config/test-flow.yaml
@@ -29,6 +29,9 @@ flow:
   test:
     nextScreens:
       - name: success
+  testUpload:
+    nextScreens:
+      - name: pageWithCustomSubmitButton
   pageWithOptionalValidation:
     nextScreens:
       - name: success
diff --git a/src/test/resources/templates/testFlow/testUpload.html b/src/test/resources/templates/testFlow/testUpload.html
new file mode 100644
index 000000000..bd8c3fbc0
--- /dev/null
+++ b/src/test/resources/templates/testFlow/testUpload.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html th:lang="${#locale.language}" xmlns:th="http://www.thymeleaf.org">
+<head th:replace="~{fragments/head :: head(title='Test Upload Screen')}"></head>
+<body
+    th:with="dzFormName='testUpload'">
+<div class="page-wrapper">
+  <div th:replace="~{fragments/toolbar :: toolbar}"></div>
+  <section class="slab">
+    <div class="grid">
+      <div th:replace="~{fragments/goBack :: goBackLink}"></div>
+      <main id="content" role="main" class="form-card spacing-above-35">
+        <th:block
+            th:replace="~{fragments/cardHeader :: cardHeader(header='Test Upload Screen')}"/>
+        <th:block
+            th:replace="~{fragments/form :: form(action=${formAction}, enctype='multipart/form-data', content=~{::contentRef}, formId=${dzFormName})}">
+          <th:block th:ref="contentRef">
+            <div class="form-card__content">
+              <th:block
+                  th:replace="~{fragments/fileUploader :: fileUploader(inputName=${dzFormName})}"></th:block>
+            </div>
+            <div id="submit" class="form-card__footer display-none">
+              <th:block th:replace="~{fragments/inputs/submitButton :: submitButton(
+                text=#{general.inputs.continue})}"/>
+            </div>
+          </th:block>
+        </th:block>
+      </main>
+    </div>
+  </section>
+</div>
+<th:block th:replace="~{fragments/footer :: footer}"/>
+<script>
+  FormFlowDZ.hideContinueIfNoFiles('[[${dzFormName}]]', 'submit');
+</script>
+</body>
+</html>

From eae5e3d655cc88f0d1ba47599ec5bfd4222cbcf9 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Thu, 16 Nov 2023 18:50:30 -0800
Subject: [PATCH 08/16] Add edge case tests

[#186001975]
---
 .../LockedSubmissionRedirectTest.java         | 133 +++++++++++++++++-
 1 file changed, 132 insertions(+), 1 deletion(-)

diff --git a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
index b9fac8559..d4513e3e6 100644
--- a/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
+++ b/src/test/java/formflow/library/controllers/LockedSubmissionRedirectTest.java
@@ -48,7 +48,7 @@ public class LockedSubmissionRedirectTest extends AbstractMockMvcTest {
   public void setUp() throws Exception {
     UUID submissionUUID = UUID.randomUUID();
     submission = Submission.builder().id(submissionUUID).urlParams(new HashMap<>()).inputData(new HashMap<>()).build();
-    // this setups flow info in the session to get passed along later on.
+    // this sets up flow info in the session to get passed along later on.
     setFlowInfoInSession(session, "testFlow", submission.getId());
     super.setUp();
   }
@@ -301,6 +301,137 @@ void shouldRedirectToConfiguredScreenWhenPostingSubflowDataToAFlowThatHasBeenCon
     assertThat(subflowIterationsAfterEdit.equals(subflowIterationsBeforeSubmit)).isTrue();
   }
   
+  @Test
+  void shouldRedirectWhenAttemptingToGetTheSubflowDeleteConfirmationScreenForAFlowWithALockedSubmission() throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/new")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInputSubflow", List.of("textInputValue"),
+            "numberInputSubflow", List.of("10"))))
+    );
+
+    // Get the UUID for the iteration we just created
+    UUID testSubflowLogicUUID = ((Map<String, UUID>) session.getAttribute(SUBMISSION_MAP_NAME)).get("testFlow");
+    Submission submissionBeforeSubflowIsCompleted = submissionRepositoryService.findById(testSubflowLogicUUID).get();
+    List<Map<String, Object>> subflowIterationsBeforeSubmit = (List<Map<String, Object>>) submissionBeforeSubflowIsCompleted.getInputData()
+        .get("testSubflow");
+    String uuidString = (String) subflowIterationsBeforeSubmit.get(0).get("uuid");
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(
+        submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    // Assert that we are redirected to the configured screen when we try to the subflow delete confirmation screen
+    mockMvc.perform(get("/flow/testFlow/testSubflow/" + uuidString + "/deleteConfirmation")
+            .session(session))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+  }
+  
+  @Test
+  void shouldRedirectWhenAttemptingToDeleteASubflowIterationFromAFlowThatIsLocked() throws Exception {
+    // Make an initial post to create the submission and give it some data
+    mockMvc.perform(post("/flow/testFlow/subflowAddItem/new")
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInputSubflow", List.of("textInputValue"),
+            "numberInputSubflow", List.of("10"))))
+    );
+
+    // Get the UUID for the iteration we just created
+    UUID testSubflowLogicUUID = ((Map<String, UUID>) session.getAttribute(SUBMISSION_MAP_NAME)).get("testFlow");
+    Submission submissionBeforeSubflowIsCompleted = submissionRepositoryService.findById(testSubflowLogicUUID).get();
+    List<Map<String, Object>> subflowIterationsBeforeSubmit = (List<Map<String, Object>>) submissionBeforeSubflowIsCompleted.getInputData()
+        .get("testSubflow");
+    String uuidString = (String) subflowIterationsBeforeSubmit.get(0).get("uuid");
+    
+    // Complete the subflow so we get a completed iteration
+    ResultActions iterationResult = mockMvc.perform(post("/flow/testFlow/subflowAddItemPage2/" + uuidString)
+        .session(session)
+        .params(new LinkedMultiValueMap<>(Map.of(
+            "textInputSubflowPage2", List.of("newValue"),
+            "moneyInputSubflowPage2", List.of("444")))));
+    
+    // We need to hit the navigation endpoint because that is where we set the iterationIsComplete flag
+    String screenAfterSubflow = "/flow/testFlow/subflowAddItemPage2/navigation?uuid=" + uuidString;
+    iterationResult.andExpect(redirectedUrl(screenAfterSubflow));
+
+    while (Objects.requireNonNull(screenAfterSubflow).contains("/navigation")) {
+      // follow redirects
+      screenAfterSubflow = mockMvc.perform(get(screenAfterSubflow).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(screenAfterSubflow).isEqualTo("/flow/testFlow/test");
+    
+
+    // Assert that the submissions submittedAt value is null before submitting
+    Map<String, UUID> submissionMap = (Map) session.getAttribute(SUBMISSION_MAP_NAME);
+    Optional<Submission> testFlowSubmission = submissionRepositoryService.findById(submissionMap.get("testFlow"));
+    assertThat(testFlowSubmission.isPresent()).isTrue();
+    assertThat(testFlowSubmission.get().getSubmittedAt()).isNull();
+    // Assert the subflow iteration is complete
+    List<Map<String, Object>> subflowIterationsBeforeSubmitting = (List<Map<String, Object>>) testFlowSubmission.get().getInputData()
+        .get("testSubflow");
+    Map<String, Object> subflowIteration = subflowIterationsBeforeSubmitting.get(0);
+    assertThat(subflowIteration.get("iterationIsComplete")).isEqualTo(true);
+    
+    // Submit the flow, assert we reach the success page
+    ResultActions result = mockMvc.perform(post("/flow/testFlow/pageWithCustomSubmitButton")
+        .session(session));
+    String nextScreenUrl = "/flow/testFlow/pageWithCustomSubmitButton/navigation";
+    result.andExpect(redirectedUrl(nextScreenUrl));
+
+    while (Objects.requireNonNull(nextScreenUrl).contains("/navigation")) {
+      // follow redirects
+      nextScreenUrl = mockMvc.perform(get(nextScreenUrl).session(session))
+          .andExpect(status().is3xxRedirection()).andReturn()
+          .getResponse()
+          .getRedirectedUrl();
+    }
+    assertThat(nextScreenUrl).isEqualTo("/flow/testFlow/success");
+    FormScreen nextScreen = new FormScreen(mockMvc.perform(get(nextScreenUrl)));
+    assertThat(nextScreen.getTitle()).isEqualTo("Success");
+
+    // Assert that the submissions submittedAt value is not null after submitting
+    Optional<Submission> testFlowSubmissionAfterBeingSubmitted = submissionRepositoryService.findById(
+        submissionMap.get("testFlow"));
+    assertThat(testFlowSubmissionAfterBeingSubmitted.isPresent()).isTrue();
+    assertThat(testFlowSubmissionAfterBeingSubmitted.get().getSubmittedAt()).isNotNull();
+    
+    // Assert that we are redirected when attempting to delete a subflow
+    mockMvc.perform(post("/flow/testFlow/testSubflow/" + uuidString + "/delete")
+            .session(session))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(redirect -> assertEquals("/flow/testFlow/success", Objects.requireNonNull(redirect.getResponse().getRedirectedUrl())));
+  }
+  
   @Test
   void shouldErrorWhenAttemptingToUploadFilesToAFlowWithALockedSubmission() throws Exception {
     // Make an initial post to create the submission and give it some data

From 47e41d2771aadbed17c8b6e0c6908f0e0f8ba663 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Thu, 16 Nov 2023 18:52:50 -0800
Subject: [PATCH 09/16] Refactory FlowsConfigurationFactory

[#186001975]
---
 .../java/formflow/library/FileController.java |  2 +-
 .../formflow/library/ScreenController.java    | 51 ++++++++-----
 .../config/FlowsConfigurationFactory.java     | 74 ++++++++++---------
 .../exceptions/ConfigurationException.java    | 10 ---
 .../FlowConfigurationException.java           |  7 ++
 5 files changed, 81 insertions(+), 63 deletions(-)
 delete mode 100644 src/main/java/formflow/library/exceptions/ConfigurationException.java
 create mode 100644 src/main/java/formflow/library/exceptions/FlowConfigurationException.java

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index f54ce21c0..7ce6e459a 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -126,7 +126,7 @@ public ResponseEntity<?> upload(
 
       if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
         String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
-        log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+        log.info("The Submission for flow {} is locked. Cannot upload file.", flow);
         String message = messageSource.getMessage("upload-documents.locked-submission", null, locale);
         return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
       }
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index 85667e316..d76c735b0 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -110,12 +110,10 @@ ModelAndView getScreen(
     // this will ensure that the screen and flow actually exist
     ScreenNavigationConfiguration currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
-    
+
     if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
-      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
-      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
-      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
-      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
 
     if ((submission.getUrlParams() != null) && (!submission.getUrlParams().isEmpty())) {
@@ -180,10 +178,8 @@ ModelAndView postScreen(
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
     if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
-      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
-      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
-      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
-      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
     
     FormSubmission formSubmission = new FormSubmission(formData);
@@ -257,10 +253,8 @@ ModelAndView getSubflowScreen(
     Submission submission = getSubmissionFromSession(httpSession, flow);
 
     if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
-      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
-      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
-      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
-      return new ModelAndView(String.format("redirect:/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
 
     if (submission == null) {
@@ -320,10 +314,8 @@ RedirectView postSubflowScreen(
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
     if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
-      String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
-      log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
-      redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
-      return new RedirectView(String.format("/flow/%s/%s", flow, lockedSubmissionRedirectPage));
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new RedirectView(lockedSubmissionRedirectUrl);
     }
     
     actionManager.handleOnPostAction(currentScreen, formSubmission, submission, iterationUuid);
@@ -405,13 +397,20 @@ ModelAndView deleteConfirmation(
       @PathVariable String subflow,
       @PathVariable String uuid,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      RedirectAttributes redirectAttributes,
+      Locale locale
   ) {
     log.info("GET deleteConfirmation (url: {}): flow: {}, uuid: {}", request.getRequestURI().toLowerCase(), flow, uuid);
     // Checks to see if flow exists
     String deleteConfirmationScreen = getFlowConfigurationByName(flow)
         .getSubflows().get(subflow).getDeleteConfirmationScreen();
     Submission submission = getSubmissionFromSession(httpSession, flow);
+    
+    if (shouldRedirectDueToLockedSubmission(flow, deleteConfirmationScreen, submission)) {
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
+    }
 
     if (submission != null) {
       var existingInputData = submission.getInputData();
@@ -439,7 +438,9 @@ ModelAndView deleteSubflowIteration(
       @PathVariable String subflow,
       @PathVariable String uuid,
       HttpSession httpSession,
-      HttpServletRequest request
+      HttpServletRequest request,
+      RedirectAttributes redirectAttributes,
+      Locale locale
   ) throws ResponseStatusException {
     log.info(
         "POST deleteSubflowIteration (url: {}): flow: {}, uuid: {}",
@@ -454,6 +455,11 @@ ModelAndView deleteSubflowIteration(
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
     }
 
+    if (shouldRedirectDueToLockedSubmission(flow, null, submission)) {
+      String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
+      return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
+    }
+
     var existingInputData = submission.getInputData();
     if (existingInputData.containsKey(subflow)) {
       var subflowArr = (ArrayList<Map<String, Object>>) existingInputData.get(subflow);
@@ -742,4 +748,11 @@ private void handleAddressValidation(Submission submission, FormSubmission formS
       });
     }
   }
+
+  private String getLockedSubmissionRedirectUrl(String flow, RedirectAttributes redirectAttributes, Locale locale) {
+    String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
+    log.info("The Submission for flow {} is locked. Redirecting to locked submission redirect page: {}", flow, lockedSubmissionRedirectPage);
+    redirectAttributes.addFlashAttribute("lockedSubmissionMessage", messageSource.getMessage("general.locked-submission", null, locale));
+    return String.format("/flow/%s/%s", flow, lockedSubmissionRedirectPage);
+  }
 }
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index 2a5cc477d..e0f1afd6b 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -1,8 +1,6 @@
 package formflow.library.config;
 
-import formflow.library.exceptions.ConfigurationException;
-import formflow.library.exceptions.LandmarkNotSetException;
-import java.io.FileNotFoundException;
+import formflow.library.exceptions.FlowConfigurationException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
@@ -17,7 +15,7 @@
 import org.yaml.snakeyaml.representer.Representer;
 
 /**
- * Parses the flow configuration yaml file and setups the FlowConfiguration list.
+ * Parses the flow configuration yaml file and adds validated flow configuration objects to the libraries list of flow configurations.
  */
 @Slf4j
 public class FlowsConfigurationFactory implements FactoryBean<List<FlowConfiguration>> {
@@ -46,45 +44,55 @@ public class FlowsConfigurationFactory implements FactoryBean<List<FlowConfigura
    */
   @Override
   public List<FlowConfiguration> getObject() throws IOException {
+    List<FlowConfiguration> flowConfigurations = new ArrayList<>();
+    try {
+      Iterable<Object> flowConfigsIterable = loadFlowConfigurationsFromYaml();
+      flowConfigsIterable.forEach(flowConfig -> addValidatedFlowConfiguration((FlowConfiguration) flowConfig, flowConfigurations));
+    } catch (IOException e) {
+      log.error("Can't find the flow configuration file: " + configPath, e);
+      throw e;
+    }
+
+    return flowConfigurations;
+  }
+  
+  private Iterable<Object> loadFlowConfigurationsFromYaml() throws IOException {
     ClassPathResource classPathResource = new ClassPathResource(configPath);
 
     LoaderOptions loaderOptions = new LoaderOptions();
     loaderOptions.setAllowDuplicateKeys(false);
     loaderOptions.setMaxAliasesForCollections(Integer.MAX_VALUE);
     loaderOptions.setAllowRecursiveKeys(true);
-
+    
     Yaml yaml = new Yaml(new Constructor(FlowConfiguration.class, loaderOptions), new Representer(new DumperOptions()),
         new DumperOptions(), loaderOptions);
-    List<FlowConfiguration> appConfigs = new ArrayList<>();
-    try {
-      Iterable<Object> appConfigsIterable = yaml.loadAll(classPathResource.getInputStream());
-      appConfigsIterable.forEach(appConfig -> {
-        FlowConfiguration flowConfig = (FlowConfiguration) appConfig;
-        
-        if (formFlowConfigurationProperties == null || !formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName())) {
-          appConfigs.add(flowConfig);
-        }
-        
-        if (formFlowConfigurationProperties != null && formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName())) {
-          if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getFirstScreen() == null) {
-            log.error("You have disabled flow {} but you did not add a landmarks first screen section to it's flow configuration file.", flowConfig.getName());
-            throw new ConfigurationException(String.format("You have disabled flow %s but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName()));
-          }
-        }
-        
-        if (formFlowConfigurationProperties != null && formFlowConfigurationProperties.isSubmissionLockedForFlow(flowConfig.getName())) {
-          if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
-            log.error("You have configured submission locking for flow {} but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName());
-            throw new ConfigurationException(String.format("You have configured submission locking for flow %s but you did not add a landmarks after submit pages section to it's flow configuration file.", flowConfig.getName()));
-          }
-        }
-      });
-    } catch (IOException e) {
-      log.error("Can't find the flow configuration file: " + configPath, e);
-      throw e;
+    return yaml.loadAll(classPathResource.getInputStream());
+  }
+
+  private void addValidatedFlowConfiguration(FlowConfiguration flowConfig, List<FlowConfiguration> flowConfigurations) {
+    if (shouldAddFlowConfiguration(flowConfig)) {
+      validateFlowConfiguration(flowConfig);
+      flowConfigurations.add(flowConfig);
     }
+  }
 
-    return appConfigs;
+  private boolean shouldAddFlowConfiguration(FlowConfiguration flowConfig) {
+    return formFlowConfigurationProperties == null || !formFlowConfigurationProperties.isFlowDisabled(flowConfig.getName());
+  }
+
+  private void validateFlowConfiguration(FlowConfiguration flowConfig) {
+    if (formFlowConfigurationProperties != null) {
+      if (formFlowConfigurationProperties.isSubmissionLockedForFlow(flowConfig.getName())) {
+        validateLandmarksAfterSubmitPages(flowConfig);
+      }
+    }
+  }
+
+  private void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
+    if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
+      throw new FlowConfigurationException("You have enabled submission locking for the flow " + flowConfig.getName() + 
+          " but the afterSubmitPages landmark is not set in your flow configuration yaml file.");
+    }
   }
 
   @Override
diff --git a/src/main/java/formflow/library/exceptions/ConfigurationException.java b/src/main/java/formflow/library/exceptions/ConfigurationException.java
deleted file mode 100644
index 79dbd8e4f..000000000
--- a/src/main/java/formflow/library/exceptions/ConfigurationException.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package formflow.library.exceptions;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.ResponseStatus;
-
-public class ConfigurationException extends RuntimeException {
-    public ConfigurationException(String message) {
-        super(message);
-    }
-}
diff --git a/src/main/java/formflow/library/exceptions/FlowConfigurationException.java b/src/main/java/formflow/library/exceptions/FlowConfigurationException.java
new file mode 100644
index 000000000..4ca658b6d
--- /dev/null
+++ b/src/main/java/formflow/library/exceptions/FlowConfigurationException.java
@@ -0,0 +1,7 @@
+package formflow.library.exceptions;
+
+public class FlowConfigurationException extends RuntimeException {
+    public FlowConfigurationException(String message) {
+        super(message);
+    }
+}

From ac51af36e3d77055c599540d54d4157e17c667df Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Fri, 17 Nov 2023 17:30:45 -0800
Subject: [PATCH 10/16] Validate first screen when session continuity
 interceptor is enabled

[#186001975]
---
 .../config/FlowsConfigurationFactory.java     |  29 +++-
 .../FlowsConfigurationFactoryConfig.java      |   4 +-
 .../exceptions/LandmarkNotSetException.java   |  11 --
 .../SessionContinuityInterceptor.java         |  25 +---
 .../config/InterceptorMockMvcTest.java        |  64 +++++++++
 .../interceptors/InterceptorMockMvcTest.java  | 134 ------------------
 6 files changed, 91 insertions(+), 176 deletions(-)
 delete mode 100644 src/main/java/formflow/library/exceptions/LandmarkNotSetException.java
 create mode 100644 src/test/java/formflow/library/config/InterceptorMockMvcTest.java
 delete mode 100644 src/test/java/formflow/library/interceptors/InterceptorMockMvcTest.java

diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index e0f1afd6b..f91a46db8 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -23,9 +23,11 @@ public class FlowsConfigurationFactory implements FactoryBean<List<FlowConfigura
   @Value("${form-flow.path:flows-config.yaml}")
   String configPath;
   
+  @Value("${form-flow.session-continuity-interceptor.enabled:false}")
+  boolean sessionContinuityInterceptorEnabled;
+  
   FormFlowConfigurationProperties formFlowConfigurationProperties;
 
-
   FlowsConfigurationFactory() {
     this.formFlowConfigurationProperties = null;
   }
@@ -81,19 +83,36 @@ private boolean shouldAddFlowConfiguration(FlowConfiguration flowConfig) {
   }
 
   private void validateFlowConfiguration(FlowConfiguration flowConfig) {
-    if (formFlowConfigurationProperties != null) {
-      if (formFlowConfigurationProperties.isSubmissionLockedForFlow(flowConfig.getName())) {
+    if (formFlowConfigurationProperties != null && formFlowConfigurationProperties.isSubmissionLockedForFlow(flowConfig.getName())) {
         validateLandmarksAfterSubmitPages(flowConfig);
-      }
+    }
+    if (sessionContinuityInterceptorEnabled) {
+      validateLandmarksFirstScreen(flowConfig);
     }
   }
 
-  private void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
+  void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
     if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
       throw new FlowConfigurationException("You have enabled submission locking for the flow " + flowConfig.getName() + 
           " but the afterSubmitPages landmark is not set in your flow configuration yaml file.");
     }
   }
+  
+  void validateLandmarksFirstScreen(FlowConfiguration flowConfig) {
+    if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getFirstScreen() == null) {
+      throw new FlowConfigurationException("You have enabled the session continuity interceptor in your application but have not added a first screen landmark for the flow " + flowConfig.getName() +
+          " in your flow configuration yaml file.");
+    }
+
+    String firstScreen = flowConfig.getLandmarks().getFirstScreen();
+
+    if (!flowConfig.getFlow().containsKey(firstScreen)) {
+      throw new FlowConfigurationException(String.format(
+          "Your flow configuration file for the flow %s does not contain a screen with the name '%s'. " +
+              "You may have misspelled the screen name. Please make sure to correctly set the 'firstScreen' in the flows configuration file 'landmarks' section.",
+          flowConfig.getName(), firstScreen));
+    }
+  }
 
   @Override
   public Class<?> getObjectType() {
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
index 302dd19df..c2af398b0 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactoryConfig.java
@@ -1,6 +1,5 @@
 package formflow.library.config;
 
-import formflow.library.exceptions.LandmarkNotSetException;
 import java.io.IOException;
 
 import org.springframework.beans.factory.annotation.Autowired;
@@ -18,7 +17,6 @@ public class FlowsConfigurationFactoryConfig {
   @Autowired(required = false)
   FormFlowConfigurationProperties formFlowConfigurationProperties;
 
-
   /**
    * Bean to get a FlowsConfigurationFactory object.
    *
@@ -38,7 +36,7 @@ public FlowsConfigurationFactory flowsConfigurationFactory() {
    * @return list of flow configuration objects
    */
   @Bean
-  public List<FlowConfiguration> flowsConfiguration() throws IOException, LandmarkNotSetException {
+  public List<FlowConfiguration> flowsConfiguration() throws IOException {
     return flowsConfigurationFactory().getObject();
   }
 }
diff --git a/src/main/java/formflow/library/exceptions/LandmarkNotSetException.java b/src/main/java/formflow/library/exceptions/LandmarkNotSetException.java
deleted file mode 100644
index 85bb40751..000000000
--- a/src/main/java/formflow/library/exceptions/LandmarkNotSetException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package formflow.library.exceptions;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.ResponseStatus;
-
-@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
-public class LandmarkNotSetException extends Exception {
-    public LandmarkNotSetException(String message) {
-        super(message);
-    }
-}
diff --git a/src/main/java/formflow/library/interceptors/SessionContinuityInterceptor.java b/src/main/java/formflow/library/interceptors/SessionContinuityInterceptor.java
index 7d4881b93..b4435c42d 100644
--- a/src/main/java/formflow/library/interceptors/SessionContinuityInterceptor.java
+++ b/src/main/java/formflow/library/interceptors/SessionContinuityInterceptor.java
@@ -3,7 +3,6 @@
 import formflow.library.FormFlowController;
 import formflow.library.ScreenController;
 import formflow.library.config.FlowConfiguration;
-import formflow.library.exceptions.LandmarkNotSetException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import jakarta.servlet.http.HttpSession;
@@ -31,7 +30,7 @@ public class SessionContinuityInterceptor implements HandlerInterceptor, Ordered
 
   private static final String REDIRECT_URL = "/";
 
-  List<FlowConfiguration> flowConfigurations;
+  public List<FlowConfiguration> flowConfigurations;
 
   public SessionContinuityInterceptor(List<FlowConfiguration> flowConfigurations) {
     this.flowConfigurations = flowConfigurations;
@@ -45,11 +44,10 @@ public SessionContinuityInterceptor(List<FlowConfiguration> flowConfigurations)
    * Screen Controller.
    * @throws IOException             - thrown in the event that an input or output exception occurs when this method does a
    *                                 redirect.
-   * @throws LandmarkNotSetException - thrown in the event that a landmark(s) screen is misconfigured
    */
   @Override
   public boolean preHandle(HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler)
-      throws IOException, LandmarkNotSetException {
+      throws IOException {
     String pathFormat = request.getRequestURI().contains("navigation") ? NAVIGATION_FLOW_PATH_FORMAT : FLOW_PATH_FORMAT;
     Map<String, String> parsedUrl = new AntPathMatcher().extractUriTemplateVariables(pathFormat, request.getRequestURI());
 
@@ -64,27 +62,8 @@ public boolean preHandle(HttpServletRequest request, @NotNull HttpServletRespons
       return true;
     }
 
-    if (flowConfiguration.getLandmarks() == null) {
-      throw new LandmarkNotSetException(
-          "The SessionContinuityInterceptor is enabled, but no 'landmarks' section has been created in the application's form " +
-              "flows configuration file.");
-    }
-
-    if (flowConfiguration.getLandmarks().getFirstScreen() == null) {
-      throw new LandmarkNotSetException(
-          "The SessionContinuityInterceptor is enabled, but a 'firstScreen' page has not " +
-              "been identified in the 'landmarks' section in the application's form flows configuration file.");
-    }
-
     String firstScreen = flowConfiguration.getLandmarks().getFirstScreen();
 
-    if (!flowConfiguration.getFlow().containsKey(firstScreen)) {
-      throw new LandmarkNotSetException(String.format(
-          "The form flows configuration file does not contain a screen with the name '%s'. " +
-              "Please make sure to correctly set the 'firstScreen' in the form flows configuration file 'landmarks' section.",
-          firstScreen));
-    }
-
     if (session == null) {
       if (parsedUrl.get("screen").equals(firstScreen)) {
         return true;
diff --git a/src/test/java/formflow/library/config/InterceptorMockMvcTest.java b/src/test/java/formflow/library/config/InterceptorMockMvcTest.java
new file mode 100644
index 000000000..cbc9cefd4
--- /dev/null
+++ b/src/test/java/formflow/library/config/InterceptorMockMvcTest.java
@@ -0,0 +1,64 @@
+package formflow.library.config;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.inOrder;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import formflow.library.interceptors.SpyInterceptorConfig;
+import formflow.library.interceptors.SessionContinuityInterceptor;
+import formflow.library.utilities.AbstractMockMvcTest;
+import java.util.HashMap;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InOrder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
+
+@SpringBootTest(properties = {"form-flow.path=flows-config/test-landmark-flow.yaml"})
+@TestPropertySource(properties = {"form-flow.session-continuity-interceptor.enabled=true"})
+@Import(SpyInterceptorConfig.class)
+class InterceptorMockMvcTest extends AbstractMockMvcTest {
+
+  @Autowired
+  private LocaleChangeInterceptor localeChangeInterceptor;
+
+  @Autowired
+  private SessionContinuityInterceptor sessionContinuityInterceptor;
+
+  @Override
+  @BeforeEach
+  protected void setUp() throws Exception {
+    // These tests dirty the context of the data, so we need to reset it before each test.
+    // We do this rather than use @DirtiesContext because it's much faster.
+    sessionContinuityInterceptor.flowConfigurations = List.of();
+    super.setUp();
+  }
+
+  @Test
+  void shouldRunTheDataRequiredInterceptorLast() throws Exception {
+    FlowConfiguration flowConfiguration = new FlowConfiguration();
+    ScreenNavigationConfiguration screenNavigationConfiguration = new ScreenNavigationConfiguration();
+    NextScreen nextScreen = new NextScreen();
+    nextScreen.setName("first");
+    screenNavigationConfiguration.setNextScreens(List.of(nextScreen));
+    HashMap<String, ScreenNavigationConfiguration> screenNavigationConfigurations = new HashMap<>();
+    screenNavigationConfigurations.put("first", screenNavigationConfiguration);
+    flowConfiguration.setFlow(screenNavigationConfigurations);
+    flowConfiguration.setName("testLandmarkFlow");
+    LandmarkConfiguration landmarkConfiguration = new LandmarkConfiguration();
+    landmarkConfiguration.setFirstScreen("first");
+    flowConfiguration.setLandmarks(landmarkConfiguration);
+    sessionContinuityInterceptor.flowConfigurations = List.of(flowConfiguration);
+    mockMvc.perform(get("/flow/testLandmarkFlow/first?lang=es"))
+        .andExpect(status().isOk());
+
+    InOrder inOrder = inOrder(localeChangeInterceptor, sessionContinuityInterceptor);
+    inOrder.verify(localeChangeInterceptor).preHandle(any(), any(), any());
+    inOrder.verify(sessionContinuityInterceptor).preHandle(any(), any(), any());
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/formflow/library/interceptors/InterceptorMockMvcTest.java b/src/test/java/formflow/library/interceptors/InterceptorMockMvcTest.java
deleted file mode 100644
index b7f25c43c..000000000
--- a/src/test/java/formflow/library/interceptors/InterceptorMockMvcTest.java
+++ /dev/null
@@ -1,134 +0,0 @@
-package formflow.library.interceptors;
-
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
-import formflow.library.config.FlowConfiguration;
-import formflow.library.config.LandmarkConfiguration;
-import formflow.library.config.NextScreen;
-import formflow.library.config.ScreenNavigationConfiguration;
-import formflow.library.exceptions.LandmarkNotSetException;
-import formflow.library.utilities.AbstractMockMvcTest;
-import java.util.HashMap;
-import java.util.List;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InOrder;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.context.annotation.Import;
-import org.springframework.test.context.TestPropertySource;
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
-import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
-
-@SpringBootTest(properties = {"form-flow.path=flows-config/test-landmark-flow.yaml"})
-@TestPropertySource(properties = {"form-flow.session-continuity-interceptor.enabled=true"})
-@Import(SpyInterceptorConfig.class)
-class InterceptorMockMvcTest extends AbstractMockMvcTest {
-
-  @Autowired
-  private LocaleChangeInterceptor localeChangeInterceptor;
-
-  @Autowired
-  private SessionContinuityInterceptor sessionContinuityInterceptor;
-
-  @Override
-  @BeforeEach
-  protected void setUp() throws Exception {
-    // These tests dirty the context of the data, so we need to reset it before each test.
-    // We do this rather than use @DirtiesContext because it's much faster.
-    sessionContinuityInterceptor.flowConfigurations = List.of();
-    super.setUp();
-  }
-
-  @Test
-  void shouldRunTheDataRequiredInterceptorLast() throws Exception {
-    FlowConfiguration flowConfiguration = new FlowConfiguration();
-    ScreenNavigationConfiguration screenNavigationConfiguration = new ScreenNavigationConfiguration();
-    NextScreen nextScreen = new NextScreen();
-    nextScreen.setName("first");
-    screenNavigationConfiguration.setNextScreens(List.of(nextScreen));
-    HashMap<String, ScreenNavigationConfiguration> screenNavigationConfigurations = new HashMap<>();
-    screenNavigationConfigurations.put("first", screenNavigationConfiguration);
-    flowConfiguration.setFlow(screenNavigationConfigurations);
-    flowConfiguration.setName("testLandmarkFlow");
-    LandmarkConfiguration landmarkConfiguration = new LandmarkConfiguration();
-    landmarkConfiguration.setFirstScreen("first");
-    flowConfiguration.setLandmarks(landmarkConfiguration);
-    sessionContinuityInterceptor.flowConfigurations = List.of(flowConfiguration);
-    mockMvc.perform(get("/flow/testLandmarkFlow/first?lang=es"))
-        .andExpect(status().isOk());
-
-    InOrder inOrder = inOrder(localeChangeInterceptor, sessionContinuityInterceptor);
-    inOrder.verify(localeChangeInterceptor).preHandle(any(), any(), any());
-    inOrder.verify(sessionContinuityInterceptor).preHandle(any(), any(), any());
-  }
-
-  @Test
-  void shouldErrorIfLandmarkIsNotSet() throws Exception {
-    FlowConfiguration flowConfiguration = new FlowConfiguration();
-    flowConfiguration.setName("testLandmarkFlow");
-    sessionContinuityInterceptor.flowConfigurations = List.of(flowConfiguration);
-    mockMvc.perform(MockMvcRequestBuilders.get("/flow/testLandmarkFlow/first"))
-        .andExpect(status().is5xxServerError())
-        .andExpect(result -> {
-          Exception resolvedException = result.getResolvedException();
-          assertTrue(resolvedException instanceof LandmarkNotSetException, "Expected RuntimeException to be thrown");
-
-          assertEquals(
-              "The SessionContinuityInterceptor is enabled, but no 'landmarks' section has been created in the application's form flows configuration file.",
-              resolvedException.getMessage());
-        });
-  }
-
-  @Test
-  void shouldErrorIfFirstScreenIsNotSet() throws Exception {
-    FlowConfiguration flowConfiguration = new FlowConfiguration();
-    flowConfiguration.setName("testLandmarkFlow");
-    LandmarkConfiguration landmarkConfiguration = new LandmarkConfiguration();
-    landmarkConfiguration.setFirstScreen(null);
-    flowConfiguration.setLandmarks(landmarkConfiguration);
-    sessionContinuityInterceptor.flowConfigurations = List.of(flowConfiguration);
-    mockMvc.perform(MockMvcRequestBuilders.get("/flow/testLandmarkFlow/first"))
-        .andExpect(status().is5xxServerError())
-        .andExpect(result -> {
-          Exception resolvedException = result.getResolvedException();
-          assertTrue(resolvedException instanceof LandmarkNotSetException, "Expected RuntimeException to be thrown");
-          assertEquals(
-              "The SessionContinuityInterceptor is enabled, but a 'firstScreen' page has not been identified in the 'landmarks' section in the application's form flows configuration file.",
-              resolvedException.getMessage());
-        });
-  }
-
-  @Test
-  void shouldErrorIfFirstScreenDoesNotExistWithinFlowConfiguration() throws Exception {
-    FlowConfiguration flowConfiguration = new FlowConfiguration();
-    ScreenNavigationConfiguration screenNavigationConfiguration = new ScreenNavigationConfiguration();
-    NextScreen nextScreen = new NextScreen();
-    nextScreen.setName("first");
-    screenNavigationConfiguration.setNextScreens(List.of(nextScreen));
-    HashMap<String, ScreenNavigationConfiguration> screenNavigationConfigurations = new HashMap<>();
-    screenNavigationConfigurations.put("first", screenNavigationConfiguration);
-    flowConfiguration.setFlow(screenNavigationConfigurations);
-    flowConfiguration.setName("testLandmarkFlow");
-    LandmarkConfiguration landmarkConfiguration = new LandmarkConfiguration();
-    landmarkConfiguration.setFirstScreen("nonExistentScreen");
-    flowConfiguration.setLandmarks(landmarkConfiguration);
-    sessionContinuityInterceptor.flowConfigurations = List.of(flowConfiguration);
-
-    mockMvc.perform(MockMvcRequestBuilders.get("/flow/testLandmarkFlow/first"))
-        .andExpect(status().is5xxServerError())
-        .andExpect(result -> {
-          Exception resolvedException = result.getResolvedException();
-          assertTrue(resolvedException instanceof LandmarkNotSetException, "Expected RuntimeException to be thrown");
-          assertEquals(
-              "The form flows configuration file does not contain a screen with the name 'nonExistentScreen'. Please make sure to correctly set the 'firstScreen' in the form flows configuration file 'landmarks' section.",
-              resolvedException.getMessage());
-        });
-  }
-}
\ No newline at end of file

From 63abc56eca746cb1469160d4b3778a38c5dff540 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Fri, 17 Nov 2023 17:31:22 -0800
Subject: [PATCH 11/16] Add tests for flows configuration vactory flow
 validations

[#186001975]
---
 .../config/FlowsConfigurationFactoryTest.java | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java

diff --git a/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java b/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java
new file mode 100644
index 000000000..bf3d5653d
--- /dev/null
+++ b/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java
@@ -0,0 +1,104 @@
+package formflow.library.config;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+
+import formflow.library.exceptions.FlowConfigurationException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.test.context.TestPropertySource;
+
+@TestPropertySource(properties = {"form-flow.session-continuity-interceptor.enabled=true"})
+public class FlowsConfigurationFactoryTest {
+
+  private FlowsConfigurationFactory flowsConfigurationFactory;
+  private FormFlowConfigurationProperties formFlowConfigurationProperties;
+  
+  private SessionContinuityInterceptorConfiguration sessionContinuityInterceptorConfiguration;
+  private ClassPathResource classPathResource;
+  
+  String AFTER_SUBIT_MISCONFIGURATION_ERROR = "You have enabled submission locking for the flow testFlow but the afterSubmitPages landmark is not set in your flow configuration yaml file.";
+  String FIRST_SCREEN_MISCONFIGURATION_ERROR = "You have enabled the session continuity interceptor in your application but have not added a first screen landmark for the flow testFlow in your flow configuration yaml file.";
+  String INCORRECT_FIRST_SCREEN_NAME_ERROR = "Your flow configuration file for the flow testFlow does not contain a screen with the name 'doesNotExistInTheFlow'. You may have misspelled the screen name. Please make sure to correctly set the 'firstScreen' in the flows configuration file 'landmarks' section.";
+  @BeforeEach
+  public void setUp() {
+    formFlowConfigurationProperties = mock(FormFlowConfigurationProperties.class);
+    sessionContinuityInterceptorConfiguration = mock(SessionContinuityInterceptorConfiguration.class);
+    classPathResource = mock(ClassPathResource.class);
+    flowsConfigurationFactory = new FlowsConfigurationFactory(formFlowConfigurationProperties);
+  }
+
+  @Test
+  public void testValidateLandmarksAfterSubmitPages_ThrowsExceptionWhenLandmarksMissing() {
+    // Create a flow that does not include a landmarks section at all
+    FlowConfiguration flowConfig = new FlowConfiguration();
+    flowConfig.setName("testFlow");
+    // The factory should throw an exception when it tries to validate the flow since there is no landmarks section but submission locking is enabled
+    FlowConfigurationException errorThrownForNoLandmarkSectionAtAll = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
+    assertThat(errorThrownForNoLandmarkSectionAtAll.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    
+    // Add a landmarks section that has no afterSubmitPages section, the factory should throw an exception due to the missing afterSubmitPages section
+    LandmarkConfiguration landmarks = new LandmarkConfiguration();
+    flowConfig.setLandmarks(landmarks);
+    FlowConfigurationException errorThrownForNoAfterSubmitLandmark = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
+    assertThat(errorThrownForNoAfterSubmitLandmark.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    
+    // Add a landmarks section that has a null afterSubmitPages section, the factory should throw an exception due to the null afterSubmitPages section
+    landmarks.setAfterSubmitPages(null);
+    flowConfig.setLandmarks(landmarks);
+    FlowConfigurationException errorThrownForEmptyAfterSubmitLandmark = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
+    assertThat(errorThrownForEmptyAfterSubmitLandmark.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    
+    // Add a landmarks section that has an afterSubmitPages section with at least one value, no error should be thrown
+    landmarks.setAfterSubmitPages(new ArrayList<>(List.of("testAfterSubmitPage")));
+    flowConfig.setLandmarks(landmarks);
+    assertDoesNotThrow(() -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
+  }
+
+  @Test
+  void testValidateLandmarksFirstScreen_ThrowsExceptionWhenLandmarksMissing() {
+    // Create a flow that does not include a landmarks section at all
+    FlowConfiguration flowConfig = new FlowConfiguration();
+    HashMap<String, ScreenNavigationConfiguration> screenNavigationConfigurations = new HashMap<>();
+    screenNavigationConfigurations.put("testFirstScreen", new ScreenNavigationConfiguration());
+    flowConfig.setFlow(screenNavigationConfigurations);
+    flowConfig.setName("testFlow");
+
+    // The factory should throw an exception when it tries to validate the flow since there is no landmarks section but session continuity interception is enabled
+    FlowConfigurationException errorThrownForNoLandmarkSectionAtAll = assertThrows(FlowConfigurationException.class,
+        () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
+    assertThat(errorThrownForNoLandmarkSectionAtAll.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+
+    // Add a landmarks section that has no firstScreen section, the factory should throw an exception due to the missing firstScreen section
+    LandmarkConfiguration landmarks = new LandmarkConfiguration();
+    flowConfig.setLandmarks(landmarks);
+    FlowConfigurationException errorThrownForNoFirstScreenLandmark = assertThrows(FlowConfigurationException.class,
+        () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
+    assertThat(errorThrownForNoFirstScreenLandmark.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+
+    // Add a landmarks section that has a null firstScreen section, the factory should throw an exception due to the null firstScreen section
+    landmarks.setFirstScreen(null);
+    flowConfig.setLandmarks(landmarks);
+    FlowConfigurationException errorThrownForEmptyFirstScreenLandmark = assertThrows(FlowConfigurationException.class,
+        () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
+    assertThat(errorThrownForEmptyFirstScreenLandmark.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+
+    // Add a landmarks section that has an incorrect firstScreen name, the factory should throw an exception since the firstScreen name does not match any screen in the flow
+    landmarks.setFirstScreen("doesNotExistInTheFlow");
+    flowConfig.setLandmarks(landmarks);
+    FlowConfigurationException errorThrownForIncorrectFirstScreenName = assertThrows(FlowConfigurationException.class,
+        () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
+    assertThat(errorThrownForIncorrectFirstScreenName.getMessage()).isEqualTo(INCORRECT_FIRST_SCREEN_NAME_ERROR);
+    
+    // Add a landmarks section that has an firstScreen section with at least one value, no error should be thrown
+    landmarks.setFirstScreen("testFirstScreen");
+    flowConfig.setLandmarks(landmarks);
+    assertDoesNotThrow(() -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
+  }
+}
\ No newline at end of file

From d3e9e42acb3ae829fe985e3a0d0e98ce995dc68c Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Fri, 17 Nov 2023 17:34:10 -0800
Subject: [PATCH 12/16] Fix method access modifiers

[#186001975]
---
 .../formflow/library/config/FlowsConfigurationFactory.java  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index f91a46db8..a2e2e0152 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -91,14 +91,14 @@ private void validateFlowConfiguration(FlowConfiguration flowConfig) {
     }
   }
 
-  void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
+  private void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
     if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
       throw new FlowConfigurationException("You have enabled submission locking for the flow " + flowConfig.getName() + 
           " but the afterSubmitPages landmark is not set in your flow configuration yaml file.");
     }
   }
-  
-  void validateLandmarksFirstScreen(FlowConfiguration flowConfig) {
+
+  protected void validateLandmarksFirstScreen(FlowConfiguration flowConfig) {
     if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getFirstScreen() == null) {
       throw new FlowConfigurationException("You have enabled the session continuity interceptor in your application but have not added a first screen landmark for the flow " + flowConfig.getName() +
           " in your flow configuration yaml file.");

From f1cc8c06e2ae535fff20fd62cdf9aa93ae3f41a9 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Fri, 17 Nov 2023 17:53:13 -0800
Subject: [PATCH 13/16] Add documentation of submission locking to the README

[#186001975]
---
 README.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/README.md b/README.md
index 037e75ba7..a28e3b754 100644
--- a/README.md
+++ b/README.md
@@ -2550,6 +2550,55 @@ form-flow:
       staticRedirectPage: '/docUploadDisabled'
 ```
 
+### Locking the Submission for a flow once it has been submitted
+
+The form flow library provides a configuration mechanism to lock a Submission object once it has been submitted.
+This will prevent users from being able to edit a Submission object once it has been submitted. If 
+configured, the user will be redirected to a configured screen if they attempt to GET or POST a page 
+within a locked flow. 
+
+Note that this does not actually lock the Submission object, but rather prevents the user from accessing
+any endpoints that would update the Submission object.
+
+When enabled, the form flow library will check if a Submission object has been submitted by looking
+for a non-null `submittedAt` value. If the `submittedAt` value is not null, and a user attempts 
+to access a screen within the flow that is not part of a list of allowed pages, the library will redirect
+the user to the configured screen. See below for more on the list of allowed pages.
+
+To enable submission locking for a given flow, add the following to your `application.yaml` file:
+
+```yaml
+form-flow:
+  lock-after-submitted:
+    - flow: ubi
+      redirect: success
+    - flow: docUpload
+      redirect: docUploadSuccess
+```
+
+If you enable submission locking for a flow, you **must** provide a list of allowed pages that can be 
+accessed after given flows Submission object has been submitted. This list of allowed pages is configured
+within your `flows-config.yaml` files `landmarks` section. See below for an example of how to configure 
+the list of allowed pages for a given flow.
+
+```yaml
+landmarks:
+  afterSubmitPages:
+    - nextSteps
+    - success
+```
+
+Note that most of the time you will only want to include static pages in the list of allowed pages. 
+This is because any data that is submitted after the submission object has been submitted will not
+be included in the PDF that is generated or in any other processes that are triggered upon submitting.
+
+An example of a time you might include a non-static page in the list of allowed pages is if you have
+a page that is used to collect feedback from the user after they have submitted their application. In
+this scenario you can include the feedback page in the list of allowed pages so that the user can
+can submit their feedback after they have submitted their application. The data would be saved
+in the Submission object, but would not be included in the PDF or any other processes that are triggered
+upon submitting.
+
 #### Design System
 
 We are moving towards using a [custom theme](https://codeforamerica.github.io/uswds/dist/) of

From 29549df19c49bd1bba2331a7e906ff57af7fe947 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Fri, 17 Nov 2023 22:54:18 -0800
Subject: [PATCH 14/16] Fix failing tests

[#186001975]
---
 .../java/formflow/library/FileController.java |  1 -
 .../formflow/library/FormFlowController.java  | 27 +++++--------------
 .../config/FlowsConfigurationFactory.java     |  2 +-
 .../controllers/FileControllerTest.java       |  7 +++++
 .../controllers/NoOpVirusScannerTest.java     |  1 +
 ...loadBlockedIfVirusScanUnreachableTest.java |  1 +
 6 files changed, 16 insertions(+), 23 deletions(-)

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index 7ce6e459a..de264c347 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -125,7 +125,6 @@ public ResponseEntity<?> upload(
       Submission submission = findOrCreateSubmission(httpSession, flow);
 
       if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
-        String lockedSubmissionRedirectPage = formFlowConfigurationProperties.getLockedSubmissionRedirect(flow);
         log.info("The Submission for flow {} is locked. Cannot upload file.", flow);
         String message = messageSource.getMessage("upload-documents.locked-submission", null, locale);
         return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index f259ace3d..a8533e2db 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -188,28 +188,13 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
    */
   public boolean shouldRedirectDueToLockedSubmission(String flowName, String screen, Submission submission) {
     FlowConfiguration flowConfig = getFlowConfigurationByName(flowName);
+    boolean submissionIsLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
     
-    if (submission == null) {
-      // This should hopefully never happen
-      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "The Submission object was null when checking if the user should be redirected due to a locked submission.");
-    }
-    
-    if (flowConfig == null) {
-      // This should hopefully never happen
-      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "The FlowConfiguration object was null when checking if the user should be redirected due to a locked submission.");
+    if (submissionIsLocked) {
+      boolean isSubmissionSubmitted = submission.getSubmittedAt() != null;
+      boolean isCurrentScreenAfterSubmit = flowConfig.getLandmarks().getAfterSubmitPages().contains(screen);
+      return isSubmissionSubmitted && !isCurrentScreenAfterSubmit;
     }
-
-    List<String> afterSubmitPages = flowConfig.getLandmarks().getAfterSubmitPages();
-    if (afterSubmitPages == null) {
-      
-      // Log error or handle the case where afterSubmitPages is null
-      return false;
-    }
-
-    boolean isSubmissionLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
-    boolean isSubmissionSubmitted = submission.getSubmittedAt() != null;
-    boolean isCurrentScreenAfterSubmit = afterSubmitPages.contains(screen);
-
-    return isSubmissionLocked && isSubmissionSubmitted && !isCurrentScreenAfterSubmit;
+    return false;
   }
 }
diff --git a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
index a2e2e0152..27275fb1d 100644
--- a/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
+++ b/src/main/java/formflow/library/config/FlowsConfigurationFactory.java
@@ -91,7 +91,7 @@ private void validateFlowConfiguration(FlowConfiguration flowConfig) {
     }
   }
 
-  private void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
+  protected void validateLandmarksAfterSubmitPages(FlowConfiguration flowConfig) {
     if (flowConfig.getLandmarks() == null || flowConfig.getLandmarks().getAfterSubmitPages() == null) {
       throw new FlowConfigurationException("You have enabled submission locking for the flow " + flowConfig.getName() + 
           " but the afterSubmitPages landmark is not set in your flow configuration yaml file.");
diff --git a/src/test/java/formflow/library/controllers/FileControllerTest.java b/src/test/java/formflow/library/controllers/FileControllerTest.java
index 3d8a49e5e..0185d1ab8 100644
--- a/src/test/java/formflow/library/controllers/FileControllerTest.java
+++ b/src/test/java/formflow/library/controllers/FileControllerTest.java
@@ -108,6 +108,7 @@ void shouldReturn404IfFlowDoesNotExist() throws Exception {
             .param("flow", "flowThatDoesNotExist")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(404));
@@ -126,6 +127,7 @@ public void fileUploadEndpointHitsCloudFileRepositoryAndAddsUserFileToSession()
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.OK.value()))
@@ -164,6 +166,7 @@ void shouldShowFileContainsVirusErrorIfClammitScanFindsVirus() throws Exception
     mockMvc.perform(MockMvcRequestBuilders.multipart("/file-upload")
             .file(testVirusFile)
             .param("flow", "testFlow")
+            .param("screen", "testUploadScreen")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
             .session(session)
@@ -187,6 +190,7 @@ void shouldAllowUploadIfBlockIfUnreachableIsSetToFalse() throws Exception {
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.OK.value()))
@@ -208,6 +212,7 @@ void shouldSetFalseIfVirusScannerDidNotRun() throws Exception {
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.OK.value()));
@@ -226,6 +231,7 @@ void shouldReturn413IfUploadedFileViolatesMaxFileSizeConstraint() throws Excepti
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.PAYLOAD_TOO_LARGE.value()))
@@ -242,6 +248,7 @@ void shouldReturn4xxIfUploadFileViolatesMaxFilesConstraint() throws Exception {
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.BAD_REQUEST.value()))
diff --git a/src/test/java/formflow/library/controllers/NoOpVirusScannerTest.java b/src/test/java/formflow/library/controllers/NoOpVirusScannerTest.java
index c60e2f62a..19d67c9b9 100644
--- a/src/test/java/formflow/library/controllers/NoOpVirusScannerTest.java
+++ b/src/test/java/formflow/library/controllers/NoOpVirusScannerTest.java
@@ -77,6 +77,7 @@ void shouldBypassRealVirusScanningIfDisabled() throws Exception {
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.OK.value()))
diff --git a/src/test/java/formflow/library/controllers/UploadBlockedIfVirusScanUnreachableTest.java b/src/test/java/formflow/library/controllers/UploadBlockedIfVirusScanUnreachableTest.java
index 8da635292..7934215f4 100644
--- a/src/test/java/formflow/library/controllers/UploadBlockedIfVirusScanUnreachableTest.java
+++ b/src/test/java/formflow/library/controllers/UploadBlockedIfVirusScanUnreachableTest.java
@@ -63,6 +63,7 @@ void shouldPreventUploadAndShowAnErrorIfBlockIfUnreachableIsSetToTrue() throws E
             .param("flow", "testFlow")
             .param("inputName", "dropZoneTestInstance")
             .param("thumbDataURL", "base64string")
+            .param("screen", "testUploadScreen")
             .session(session)
             .contentType(MediaType.MULTIPART_FORM_DATA_VALUE))
         .andExpect(status().is(HttpStatus.SERVICE_UNAVAILABLE.value()))

From c73b38ccd9523eb5e16c9a90997716586d431411 Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Mon, 27 Nov 2023 17:18:58 -0800
Subject: [PATCH 15/16] Cleanup from code walk through

[#186402592]
---
 .../java/formflow/library/FileController.java |  6 +---
 .../formflow/library/FormFlowController.java  | 12 ++++----
 .../formflow/library/ScreenController.java    | 12 ++++----
 .../config/FlowsConfigurationFactoryTest.java | 28 ++++++++-----------
 4 files changed, 24 insertions(+), 34 deletions(-)

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index de264c347..b9dbca869 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -17,7 +17,6 @@
 import jakarta.servlet.http.HttpSession;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.net.URI;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -46,10 +45,7 @@
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.reactive.function.client.WebClientResponseException;
 import org.springframework.web.server.ResponseStatusException;
-import org.springframework.web.servlet.ModelAndView;
 import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
-import org.springframework.web.servlet.mvc.support.RedirectAttributes;
-import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
 import org.springframework.web.servlet.view.RedirectView;
 
 @Controller
@@ -124,7 +120,7 @@ public ResponseEntity<?> upload(
 
       Submission submission = findOrCreateSubmission(httpSession, flow);
 
-      if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+      if (shouldRedirectDueToLockedSubmission(screen, submission)) {
         log.info("The Submission for flow {} is locked. Cannot upload file.", flow);
         String message = messageSource.getMessage("upload-documents.locked-submission", null, locale);
         return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index a8533e2db..6566d4bdd 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -6,7 +6,6 @@
 import formflow.library.data.SubmissionRepositoryService;
 import formflow.library.data.UserFileRepositoryService;
 import jakarta.servlet.http.HttpSession;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
@@ -181,14 +180,13 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
   /**
    * Determines if the user should be redirected due to a locked submission.
    *
-   * @param flowName     The name of the flow.
-   * @param screen       The current screen name.
-   * @param submission   The submission object.
+   * @param screen     The current screen name.
+   * @param submission The submission object.
    * @return true if the user should be redirected, false otherwise.
    */
-  public boolean shouldRedirectDueToLockedSubmission(String flowName, String screen, Submission submission) {
-    FlowConfiguration flowConfig = getFlowConfigurationByName(flowName);
-    boolean submissionIsLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
+  public boolean shouldRedirectDueToLockedSubmission(String screen, Submission submission) {
+    FlowConfiguration flowConfig = getFlowConfigurationByName(submission.getFlow());
+    boolean submissionIsLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(submission.getFlow());
     
     if (submissionIsLocked) {
       boolean isSubmissionSubmitted = submission.getSubmittedAt() != null;
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index d76c735b0..e90dfdafc 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -111,7 +111,7 @@ ModelAndView getScreen(
     ScreenNavigationConfiguration currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -177,7 +177,7 @@ ModelAndView postScreen(
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -252,7 +252,7 @@ ModelAndView getSubflowScreen(
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = getSubmissionFromSession(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -313,7 +313,7 @@ RedirectView postSubflowScreen(
     String subflowName = currentScreen.getSubflow();
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(flow, screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new RedirectView(lockedSubmissionRedirectUrl);
     }
@@ -407,7 +407,7 @@ ModelAndView deleteConfirmation(
         .getSubflows().get(subflow).getDeleteConfirmationScreen();
     Submission submission = getSubmissionFromSession(httpSession, flow);
     
-    if (shouldRedirectDueToLockedSubmission(flow, deleteConfirmationScreen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(deleteConfirmationScreen, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -455,7 +455,7 @@ ModelAndView deleteSubflowIteration(
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
     }
 
-    if (shouldRedirectDueToLockedSubmission(flow, null, submission)) {
+    if (shouldRedirectDueToLockedSubmission(null, submission)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
diff --git a/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java b/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java
index bf3d5653d..97e4ac492 100644
--- a/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java
+++ b/src/test/java/formflow/library/config/FlowsConfigurationFactoryTest.java
@@ -2,6 +2,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.mock;
 
@@ -18,19 +19,14 @@
 public class FlowsConfigurationFactoryTest {
 
   private FlowsConfigurationFactory flowsConfigurationFactory;
-  private FormFlowConfigurationProperties formFlowConfigurationProperties;
-  
-  private SessionContinuityInterceptorConfiguration sessionContinuityInterceptorConfiguration;
-  private ClassPathResource classPathResource;
-  
-  String AFTER_SUBIT_MISCONFIGURATION_ERROR = "You have enabled submission locking for the flow testFlow but the afterSubmitPages landmark is not set in your flow configuration yaml file.";
+
+
+  String AFTER_SUBMIT_MISCONFIGURATION_ERROR = "You have enabled submission locking for the flow testFlow but the afterSubmitPages landmark is not set in your flow configuration yaml file.";
   String FIRST_SCREEN_MISCONFIGURATION_ERROR = "You have enabled the session continuity interceptor in your application but have not added a first screen landmark for the flow testFlow in your flow configuration yaml file.";
   String INCORRECT_FIRST_SCREEN_NAME_ERROR = "Your flow configuration file for the flow testFlow does not contain a screen with the name 'doesNotExistInTheFlow'. You may have misspelled the screen name. Please make sure to correctly set the 'firstScreen' in the flows configuration file 'landmarks' section.";
   @BeforeEach
   public void setUp() {
-    formFlowConfigurationProperties = mock(FormFlowConfigurationProperties.class);
-    sessionContinuityInterceptorConfiguration = mock(SessionContinuityInterceptorConfiguration.class);
-    classPathResource = mock(ClassPathResource.class);
+    FormFlowConfigurationProperties formFlowConfigurationProperties = mock(FormFlowConfigurationProperties.class);
     flowsConfigurationFactory = new FlowsConfigurationFactory(formFlowConfigurationProperties);
   }
 
@@ -41,19 +37,19 @@ public void testValidateLandmarksAfterSubmitPages_ThrowsExceptionWhenLandmarksMi
     flowConfig.setName("testFlow");
     // The factory should throw an exception when it tries to validate the flow since there is no landmarks section but submission locking is enabled
     FlowConfigurationException errorThrownForNoLandmarkSectionAtAll = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
-    assertThat(errorThrownForNoLandmarkSectionAtAll.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForNoLandmarkSectionAtAll.getMessage(), AFTER_SUBMIT_MISCONFIGURATION_ERROR);
     
     // Add a landmarks section that has no afterSubmitPages section, the factory should throw an exception due to the missing afterSubmitPages section
     LandmarkConfiguration landmarks = new LandmarkConfiguration();
     flowConfig.setLandmarks(landmarks);
     FlowConfigurationException errorThrownForNoAfterSubmitLandmark = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
-    assertThat(errorThrownForNoAfterSubmitLandmark.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForNoAfterSubmitLandmark.getMessage(), AFTER_SUBMIT_MISCONFIGURATION_ERROR);
     
     // Add a landmarks section that has a null afterSubmitPages section, the factory should throw an exception due to the null afterSubmitPages section
     landmarks.setAfterSubmitPages(null);
     flowConfig.setLandmarks(landmarks);
     FlowConfigurationException errorThrownForEmptyAfterSubmitLandmark = assertThrows(FlowConfigurationException.class, () -> flowsConfigurationFactory.validateLandmarksAfterSubmitPages(flowConfig));
-    assertThat(errorThrownForEmptyAfterSubmitLandmark.getMessage()).isEqualTo(AFTER_SUBIT_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForEmptyAfterSubmitLandmark.getMessage(), AFTER_SUBMIT_MISCONFIGURATION_ERROR);
     
     // Add a landmarks section that has an afterSubmitPages section with at least one value, no error should be thrown
     landmarks.setAfterSubmitPages(new ArrayList<>(List.of("testAfterSubmitPage")));
@@ -73,28 +69,28 @@ void testValidateLandmarksFirstScreen_ThrowsExceptionWhenLandmarksMissing() {
     // The factory should throw an exception when it tries to validate the flow since there is no landmarks section but session continuity interception is enabled
     FlowConfigurationException errorThrownForNoLandmarkSectionAtAll = assertThrows(FlowConfigurationException.class,
         () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
-    assertThat(errorThrownForNoLandmarkSectionAtAll.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForNoLandmarkSectionAtAll.getMessage(), FIRST_SCREEN_MISCONFIGURATION_ERROR);
 
     // Add a landmarks section that has no firstScreen section, the factory should throw an exception due to the missing firstScreen section
     LandmarkConfiguration landmarks = new LandmarkConfiguration();
     flowConfig.setLandmarks(landmarks);
     FlowConfigurationException errorThrownForNoFirstScreenLandmark = assertThrows(FlowConfigurationException.class,
         () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
-    assertThat(errorThrownForNoFirstScreenLandmark.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForNoFirstScreenLandmark.getMessage(), FIRST_SCREEN_MISCONFIGURATION_ERROR);
 
     // Add a landmarks section that has a null firstScreen section, the factory should throw an exception due to the null firstScreen section
     landmarks.setFirstScreen(null);
     flowConfig.setLandmarks(landmarks);
     FlowConfigurationException errorThrownForEmptyFirstScreenLandmark = assertThrows(FlowConfigurationException.class,
         () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
-    assertThat(errorThrownForEmptyFirstScreenLandmark.getMessage()).isEqualTo(FIRST_SCREEN_MISCONFIGURATION_ERROR);
+    assertEquals(errorThrownForEmptyFirstScreenLandmark.getMessage(), FIRST_SCREEN_MISCONFIGURATION_ERROR);
 
     // Add a landmarks section that has an incorrect firstScreen name, the factory should throw an exception since the firstScreen name does not match any screen in the flow
     landmarks.setFirstScreen("doesNotExistInTheFlow");
     flowConfig.setLandmarks(landmarks);
     FlowConfigurationException errorThrownForIncorrectFirstScreenName = assertThrows(FlowConfigurationException.class,
         () -> flowsConfigurationFactory.validateLandmarksFirstScreen(flowConfig));
-    assertThat(errorThrownForIncorrectFirstScreenName.getMessage()).isEqualTo(INCORRECT_FIRST_SCREEN_NAME_ERROR);
+    assertEquals(errorThrownForIncorrectFirstScreenName.getMessage(), INCORRECT_FIRST_SCREEN_NAME_ERROR);
     
     // Add a landmarks section that has an firstScreen section with at least one value, no error should be thrown
     landmarks.setFirstScreen("testFirstScreen");

From 436bae0b066ab727982d964539936798ce154e3c Mon Sep 17 00:00:00 2001
From: spokenbird <agonzalez@codeforamerica.org>
Date: Tue, 28 Nov 2023 14:28:33 -0800
Subject: [PATCH 16/16] Revert shouldRedirectDueToLockedSubmission signature
 change to fix failing tests

[#186402592]
---
 src/main/java/formflow/library/FileController.java   |  2 +-
 .../java/formflow/library/FormFlowController.java    |  7 ++++---
 src/main/java/formflow/library/ScreenController.java | 12 ++++++------
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/main/java/formflow/library/FileController.java b/src/main/java/formflow/library/FileController.java
index b9dbca869..9b2d33439 100644
--- a/src/main/java/formflow/library/FileController.java
+++ b/src/main/java/formflow/library/FileController.java
@@ -120,7 +120,7 @@ public ResponseEntity<?> upload(
 
       Submission submission = findOrCreateSubmission(httpSession, flow);
 
-      if (shouldRedirectDueToLockedSubmission(screen, submission)) {
+      if (shouldRedirectDueToLockedSubmission(screen, submission,flow)) {
         log.info("The Submission for flow {} is locked. Cannot upload file.", flow);
         String message = messageSource.getMessage("upload-documents.locked-submission", null, locale);
         return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
diff --git a/src/main/java/formflow/library/FormFlowController.java b/src/main/java/formflow/library/FormFlowController.java
index 6566d4bdd..35b9621b0 100644
--- a/src/main/java/formflow/library/FormFlowController.java
+++ b/src/main/java/formflow/library/FormFlowController.java
@@ -182,11 +182,12 @@ protected void setSubmissionInSession(HttpSession session, Submission submission
    *
    * @param screen     The current screen name.
    * @param submission The submission object.
+   * @param flowName
    * @return true if the user should be redirected, false otherwise.
    */
-  public boolean shouldRedirectDueToLockedSubmission(String screen, Submission submission) {
-    FlowConfiguration flowConfig = getFlowConfigurationByName(submission.getFlow());
-    boolean submissionIsLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(submission.getFlow());
+  public boolean shouldRedirectDueToLockedSubmission(String screen, Submission submission, String flowName) {
+    FlowConfiguration flowConfig = getFlowConfigurationByName(flowName);
+    boolean submissionIsLocked = this.formFlowConfigurationProperties.isSubmissionLockedForFlow(flowName);
     
     if (submissionIsLocked) {
       boolean isSubmissionSubmitted = submission.getSubmittedAt() != null;
diff --git a/src/main/java/formflow/library/ScreenController.java b/src/main/java/formflow/library/ScreenController.java
index e90dfdafc..bdb782ea2 100644
--- a/src/main/java/formflow/library/ScreenController.java
+++ b/src/main/java/formflow/library/ScreenController.java
@@ -111,7 +111,7 @@ ModelAndView getScreen(
     ScreenNavigationConfiguration currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -177,7 +177,7 @@ ModelAndView postScreen(
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -252,7 +252,7 @@ ModelAndView getSubflowScreen(
     var currentScreen = getScreenConfig(flow, screen);
     Submission submission = getSubmissionFromSession(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -313,7 +313,7 @@ RedirectView postSubflowScreen(
     String subflowName = currentScreen.getSubflow();
     Submission submission = findOrCreateSubmission(httpSession, flow);
 
-    if (shouldRedirectDueToLockedSubmission(screen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(screen, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new RedirectView(lockedSubmissionRedirectUrl);
     }
@@ -407,7 +407,7 @@ ModelAndView deleteConfirmation(
         .getSubflows().get(subflow).getDeleteConfirmationScreen();
     Submission submission = getSubmissionFromSession(httpSession, flow);
     
-    if (shouldRedirectDueToLockedSubmission(deleteConfirmationScreen, submission)) {
+    if (shouldRedirectDueToLockedSubmission(deleteConfirmationScreen, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }
@@ -455,7 +455,7 @@ ModelAndView deleteSubflowIteration(
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
     }
 
-    if (shouldRedirectDueToLockedSubmission(null, submission)) {
+    if (shouldRedirectDueToLockedSubmission(null, submission, flow)) {
       String lockedSubmissionRedirectUrl = getLockedSubmissionRedirectUrl(flow, redirectAttributes, locale);
       return new ModelAndView("redirect:" + lockedSubmissionRedirectUrl);
     }