@elliemae/loan-field-renderers 26.2.2

package/dist/cjs/tests/flows/zipCodeRendererFlows.js

@@ -0,0 +1,1163 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var zipCodeRendererFlows_exports = {};
+__export(zipCodeRendererFlows_exports, {
+  ZipCodeRendererFlows: () => ZipCodeRendererFlows
+});
+module.exports = __toCommonJS(zipCodeRendererFlows_exports);
+var import_flow_driven_testing = require("@elliemae/flow-driven-testing");
+var import_react = require("@testing-library/react");
+var import_flowBase = require("../base/flowBase");
+const triggerZipLookupWithWait = async (selector, value) => {
+  const input = document.querySelector(selector);
+  if (input) {
+    import_react.fireEvent.change(input, { target: { value } });
+    await new Promise((resolve) => {
+      setTimeout(resolve, 300);
+    });
+  }
+};
+const triggerBlurWithWait = async (selector, value) => {
+  const input = document.querySelector(selector);
+  if (input) {
+    if (value !== void 0) {
+      import_react.fireEvent.change(input, { target: { value } });
+    }
+    import_react.fireEvent.focusOut(input);
+    await new Promise((resolve) => {
+      setTimeout(resolve, 200);
+    });
+  }
+};
+class ZipCodeRendererFlows extends import_flowBase.FlowBase {
+  constructor(flowParams) {
+    super(flowParams);
+    this.flowParams = flowParams;
+  }
+  flowParams;
+  /**
+   * Test 1: Verify zip code field renders correctly
+   */
+  CheckZipCodeRendering() {
+    return {
+      [`${this.flowParams.inboundFlow}`]: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check zip code field renders correctly"
+        ),
+        asserts: [
+          {
+            selector: '[data-testid="FR0108"]',
+            isExists: true
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeInputValue"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 2: Enter a valid 5-digit zip code and verify it triggers lookup
+   * Using 90210 which returns single result (auto-fill)
+   */
+  CheckZipCodeInputValue() {
+    return {
+      checkZipCodeInputValue: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check zip code input triggers lookup"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="FR0108"]', "90210");
+            }
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value === "90210";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeBlurEvent"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 3: Verify blur event triggers SSF setFields
+   */
+  CheckZipCodeBlurEvent() {
+    return {
+      checkZipCodeBlurEvent: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check blur event triggers SSF setFields"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerBlurWithWait('[data-testid="FR0108"]', "90210");
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value === "90210";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkGeoFieldsAutoFill"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 4: Verify geo fields are auto-filled after single result lookup
+   * FR0108 has geoFields: city=FR0106, state=FR0107, county=FR0109
+   */
+  CheckGeoFieldsAutoFill() {
+    return {
+      checkGeoFieldsAutoFill: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check geo fields auto-fill after lookup"
+        ),
+        asserts: [
+          {
+            assertFn: () => {
+              const cityField = document.querySelector(
+                '[data-testid="FR0106"]'
+              );
+              return cityField !== null;
+            }
+          },
+          {
+            assertFn: () => {
+              const stateField = document.querySelector(
+                '[data-testid="FR0107"]'
+              );
+              return stateField !== null;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkSecondZipCodeExists"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 5: Verify second zip code field exists
+   */
+  CheckSecondZipCodeExists() {
+    return {
+      checkSecondZipCodeExists: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check second zip code field exists"
+        ),
+        asserts: [
+          {
+            selector: '[data-testid="15"]',
+            isExists: true
+          }
+        ],
+        transitions: [
+          {
+            to: "checkMultipleResultsDropdown"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 6: Enter zip with multiple results to trigger autocomplete dropdown
+   * Using 10001 which returns multiple results
+   */
+  CheckMultipleResultsDropdown() {
+    return {
+      checkMultipleResultsDropdown: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check autocomplete dropdown appears for multiple results"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="15"]', "10001");
+            }
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement && inputElement.value === "10001";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkAutocompleteOptionSelect"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 7: Verify autocomplete behavior works with blur (fallback path)
+   */
+  CheckAutocompleteOptionSelect() {
+    return {
+      checkAutocompleteOptionSelect: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check selecting option from autocomplete"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerBlurWithWait('[data-testid="15"]', "10001");
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement && inputElement.value === "10001";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeClearValue"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 8: Verify zip code field can be cleared
+   */
+  CheckZipCodeClearValue() {
+    return {
+      checkZipCodeClearValue: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check zip code can be cleared"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              const input = document.querySelector(
+                '[data-testid="15"]'
+              );
+              if (input) {
+                import_react.fireEvent.change(input, { target: { value: "" } });
+                await new Promise((resolve) => {
+                  setTimeout(resolve, 100);
+                });
+              }
+            }
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement && inputElement.value === "";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkNonDigitInput"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 9a: Test non-digit input handling (should be rejected)
+   * This covers the early return in handleUSZipChange for non-digit values
+   */
+  CheckNonDigitInput() {
+    return {
+      checkNonDigitInput: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check non-digit input is rejected"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              const input = document.querySelector(
+                '[data-testid="15"]'
+              );
+              if (input) {
+                import_react.fireEvent.change(input, { target: { value: "abc" } });
+                await new Promise((resolve) => {
+                  setTimeout(resolve, 100);
+                });
+              }
+            }
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement !== null;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkThirdZipCodeExists"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 9: Verify third zip code field exists (1260)
+   */
+  CheckThirdZipCodeExists() {
+    return {
+      checkThirdZipCodeExists: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check third zip code field exists"
+        ),
+        asserts: [
+          {
+            selector: '[data-testid="1260"]',
+            isExists: true
+          }
+        ],
+        transitions: [
+          {
+            to: "checkThirdZipCodeInput"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 10: Enter value in third zip code field with auto-fill
+   */
+  CheckThirdZipCodeInput() {
+    return {
+      checkThirdZipCodeInput: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check third zip code input with auto-fill"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="1260"]', "94105");
+              await triggerBlurWithWait('[data-testid="1260"]');
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1260"]'
+              );
+              return inputElement && inputElement.value === "94105";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkPartialZipCode"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 11: Verify partial zip code doesn't trigger lookup
+   * Less than 5 digits should not trigger lookup
+   */
+  CheckPartialZipCode() {
+    return {
+      checkPartialZipCode: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check partial zip code does not trigger lookup"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "902",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value === "902";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeValueChange"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 12: Verify zip code value changes are tracked
+   */
+  CheckZipCodeValueChange() {
+    return {
+      checkZipCodeValueChange: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check zip code value changes are tracked"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="FR0108"]', "75001");
+              await triggerBlurWithWait('[data-testid="FR0108"]');
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value === "75001";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeValidation"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 13: Verify validation is executed on blur
+   */
+  CheckZipCodeValidation() {
+    return {
+      checkZipCodeValidation: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check validation executes on blur"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="FR0108"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const errorElement = document.querySelector(
+                '[id="FR0108_error_message"] span'
+              );
+              return !errorElement;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeWithDifferentGeoFields"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 14: Test zip code with different geo field configuration
+   * Field 1419 has country field in geoFields and isForeignAddress=true
+   */
+  CheckZipCodeWithDifferentGeoFields() {
+    return {
+      checkZipCodeWithDifferentGeoFields: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check zip code with country geo field"
+        ),
+        asserts: [
+          {
+            selector: '[data-testid="1419"]',
+            isExists: true
+          }
+        ],
+        transitions: [
+          {
+            to: "checkFourthZipCodeInput"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 15: Enter value in fourth zip code field (foreign address)
+   */
+  CheckFourthZipCodeInput() {
+    return {
+      checkFourthZipCodeInput: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check fourth zip code field input"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1419"]',
+            value: "SW1A 1AA",
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement && inputElement.value === "SW1A 1AA";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeSequentialChanges"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 16: Test zip code with sequential value changes to cover onChange path
+   */
+  CheckZipCodeSequentialChanges() {
+    return {
+      checkZipCodeSequentialChanges: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check sequential value changes"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "9",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "90",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "902",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "9021",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="FR0108"]',
+            value: "90210",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value === "90210";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeInputFocus"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 17: Test input focus and blur cycle
+   */
+  CheckZipCodeInputFocus() {
+    return {
+      checkZipCodeInputFocus: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check input focus and blur cycle"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1260"]',
+            action: import_flow_driven_testing.TTriggerActions.CLICK
+          },
+          {
+            selector: '[data-testid="1260"]',
+            value: "75001",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="1260"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1260"]'
+              );
+              return inputElement && inputElement.value === "75001";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeWithEmptyBlur"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 18: Test empty value on blur (covers clearOptions path)
+   */
+  CheckZipCodeWithEmptyBlur() {
+    return {
+      checkZipCodeWithEmptyBlur: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check empty value on blur clears properly"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1260"]',
+            value: "",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="1260"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1260"]'
+              );
+              return inputElement && inputElement.value === "";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeNoResultsLookup"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 19: Test zip code that returns no results
+   * Using 00000 which should return empty results
+   */
+  CheckZipCodeNoResultsLookup() {
+    return {
+      checkZipCodeNoResultsLookup: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check no results lookup handling"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="15"]', "00000");
+              await triggerBlurWithWait('[data-testid="15"]');
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement && inputElement.value === "00000";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeReEntryValue"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 20: Test re-entering zip code value after clear
+   */
+  CheckZipCodeReEntryValue() {
+    return {
+      checkZipCodeReEntryValue: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check re-entry value after clear"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              await triggerZipLookupWithWait('[data-testid="15"]', "94105");
+              await triggerBlurWithWait('[data-testid="15"]');
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="15"]'
+              );
+              return inputElement && inputElement.value === "94105";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeBlurWithValue"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 21: Test blur event with existing value (validation path)
+   */
+  CheckZipCodeBlurWithValue() {
+    return {
+      checkZipCodeBlurWithValue: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check blur with existing value triggers validation"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="FR0108"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          }
+        ],
+        transitions: [
+          {
+            to: "checkForeignAddressFieldRendering"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 22: Verify foreign address field renders correctly
+   * Field 1419 has isForeignAddress=true
+   */
+  CheckForeignAddressFieldRendering() {
+    return {
+      checkForeignAddressFieldRendering: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check foreign address field renders correctly"
+        ),
+        asserts: [
+          {
+            selector: '[data-testid="1419"]',
+            isExists: true
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement !== null;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkForeignAddressInput"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 23: Test foreign address input (covers handleForeignAddressChange)
+   */
+  CheckForeignAddressInput() {
+    return {
+      checkForeignAddressInput: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check foreign address input handling"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1419"]',
+            value: "EC1A 1BB",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          }
+        ],
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement && inputElement.value === "EC1A 1BB";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkForeignAddressBlur"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 24: Test foreign address blur event
+   */
+  CheckForeignAddressBlur() {
+    return {
+      checkForeignAddressBlur: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check foreign address blur triggers SSF"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1419"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement && inputElement.value === "EC1A 1BB";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkForeignAddressValueChange"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 25: Test foreign address value change
+   */
+  CheckForeignAddressValueChange() {
+    return {
+      checkForeignAddressValueChange: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check foreign address value change"
+        ),
+        startFlow: [
+          {
+            selector: '[data-testid="1419"]',
+            value: "W1A 0AX",
+            action: import_flow_driven_testing.TTriggerActions.CHANGE
+          },
+          {
+            selector: '[data-testid="1419"]',
+            action: import_flow_driven_testing.TTriggerActions.BLUR
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement && inputElement.value === "W1A 0AX";
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkForeignAddressFinalState"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 26: Verify foreign address final state
+   */
+  CheckForeignAddressFinalState() {
+    return {
+      checkForeignAddressFinalState: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check foreign address final state"
+        ),
+        asserts: [
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="1419"]'
+              );
+              return inputElement && inputElement.value.length > 0;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkAutocompleteMenuSelection"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 27: Trigger lookup to show autocomplete menu and select an option
+   * This covers handleOptionSelect path and autocomplete interactions
+   */
+  CheckAutocompleteMenuSelection() {
+    return {
+      checkAutocompleteMenuSelection: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check autocomplete menu selection triggers geo fill"
+        ),
+        waitForTimeout: 5e3,
+        startFlow: [
+          {
+            method: async () => {
+              const input = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              if (input) {
+                import_react.fireEvent.focus(input);
+                import_react.fireEvent.change(input, { target: { value: "10001" } });
+                await new Promise((resolve) => {
+                  setTimeout(resolve, 400);
+                });
+                const menuOptions = document.querySelectorAll(
+                  '[role="listbox"] [role="option"], [data-testid*="autocomplete"] li, .ds-autocomplete-menu li, ul[role="listbox"] li'
+                );
+                if (menuOptions.length > 0) {
+                  import_react.fireEvent.click(menuOptions[0]);
+                  await new Promise((resolve) => {
+                    setTimeout(resolve, 200);
+                  });
+                }
+                import_react.fireEvent.blur(input);
+                await new Promise((resolve) => {
+                  setTimeout(resolve, 200);
+                });
+              }
+            }
+          }
+        ],
+        asserts: [
+          {
+            ssfFunctionsCalled: ["setFields"]
+          },
+          {
+            assertFn: () => {
+              const inputElement = document.querySelector(
+                '[data-testid="FR0108"]'
+              );
+              return inputElement && inputElement.value.length > 0;
+            }
+          }
+        ],
+        transitions: [
+          {
+            to: "checkZipCodeFinalState"
+          }
+        ]
+      }
+    };
+  }
+  /**
+   * Test 28: Final state verification - all zip code fields present and valid
+   */
+  CheckZipCodeFinalState() {
+    const transitions = this.flowParams.outboundFlow ? [{ to: this.flowParams.outboundFlow }] : [];
+    return {
+      checkZipCodeFinalState: {
+        name: this.getFlowName(
+          "ZipCodeRenderer",
+          "check all zip code fields final state is valid"
+        ),
+        asserts: [
+          {
+            assertFn: () => {
+              const zip1 = document.querySelector('[data-testid="FR0108"]');
+              const zip2 = document.querySelector('[data-testid="15"]');
+              const zip3 = document.querySelector('[data-testid="1260"]');
+              const zip4 = document.querySelector('[data-testid="1419"]');
+              return zip1 !== null && zip2 !== null && zip3 !== null && zip4 !== null;
+            }
+          }
+        ],
+        ...transitions.length > 0 && { transitions }
+      }
+    };
+  }
+  get Flows() {
+    return {
+      ...this.CheckZipCodeRendering(),
+      ...this.CheckZipCodeInputValue(),
+      ...this.CheckZipCodeBlurEvent(),
+      ...this.CheckGeoFieldsAutoFill(),
+      ...this.CheckSecondZipCodeExists(),
+      ...this.CheckMultipleResultsDropdown(),
+      ...this.CheckAutocompleteOptionSelect(),
+      ...this.CheckZipCodeClearValue(),
+      ...this.CheckNonDigitInput(),
+      ...this.CheckThirdZipCodeExists(),
+      ...this.CheckThirdZipCodeInput(),
+      ...this.CheckPartialZipCode(),
+      ...this.CheckZipCodeValueChange(),
+      ...this.CheckZipCodeValidation(),
+      ...this.CheckZipCodeWithDifferentGeoFields(),
+      ...this.CheckFourthZipCodeInput(),
+      ...this.CheckZipCodeSequentialChanges(),
+      ...this.CheckZipCodeInputFocus(),
+      ...this.CheckZipCodeWithEmptyBlur(),
+      ...this.CheckZipCodeNoResultsLookup(),
+      ...this.CheckZipCodeReEntryValue(),
+      ...this.CheckZipCodeBlurWithValue(),
+      ...this.CheckForeignAddressFieldRendering(),
+      ...this.CheckForeignAddressInput(),
+      ...this.CheckForeignAddressBlur(),
+      ...this.CheckForeignAddressValueChange(),
+      ...this.CheckForeignAddressFinalState(),
+      ...this.CheckAutocompleteMenuSelection(),
+      ...this.CheckZipCodeFinalState()
+    };
+  }
+}