Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-11720): mock supports_text_input in tel/card routing test (unblocks main) (#7266)
Andrew Neilsond0228f6c1d06
diff --git a/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.test.tsx b/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.test.tsxindex a50dae596..522070c9c 100644--- a/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.test.tsx+++ b/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.test.tsx@@ -32,7 +32,7 @@ function LocationProbe() {);}-function renderAt(path: string) {+function renderAt(path: string, element = <RunStopButton />) {const queryClient = new QueryClient({defaultOptions: { queries: { retry: false }, mutations: { retry: false } },});@@ -43,7 +43,7 @@ function renderAt(path: string) {<Routes><Routepath="/workflows/:workflowPermanentId/studio"- element={<RunStopButton />}+ element={element}/><Routepath="/agents/:workflowPermanentId/run"@@ -129,3 +129,41 @@ describe("RunStopButton concurrency with a live block run", () => {);});});++// Global workflows can't start runs from the studio, but recipe pages run+// them in place — a live run must still be stoppable from the top bar.+describe("RunStopButton stopOnly (global workflows)", () => {+ test("a running run offers Stop and no Run", () => {+ renderAt("/workflows/wpid_1/studio?wr=wr_1", <RunStopButton stopOnly />);+ expect(screen.queryByRole("button", { name: /Stop/ })).not.toBeNull();+ expect(screen.queryByRole("button", { name: /Run/ })).toBeNull();+ });++ test("a running block run offers Stop only — no concurrent full run", () => {+ renderAt(+ "/workflows/wpid_1/studio?wr=wr_1&bl=Block%201",+ <RunStopButton stopOnly />,+ );+ expect(screen.queryByRole("button", { name: /Stop/ })).not.toBeNull();+ expect(screen.queryByRole("button", { name: /Run/ })).toBeNull();+ });++ test("stopping asks for the same soft confirm", () => {+ renderAt("/workflows/wpid_1/studio?wr=wr_1", <RunStopButton stopOnly />);++ fireEvent.click(screen.getByRole("button", { name: /Stop/ }));+ expect(screen.queryByText("Stop this run?")).not.toBeNull();+ });++ test("a finished run renders nothing", () => {+ mockRun(Status.Completed);+ renderAt("/workflows/wpid_1/studio?wr=wr_1", <RunStopButton stopOnly />);+ expect(screen.queryByRole("button")).toBeNull();+ });++ test("no focused run renders nothing", () => {+ workflowRunQueryMock.mockReturnValue({ data: undefined });+ renderAt("/workflows/wpid_1/studio", <RunStopButton stopOnly />);+ expect(screen.queryByRole("button")).toBeNull();+ });+});diff --git a/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.tsx b/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.tsxindex d438c6225..e61e7e2ea 100644--- a/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.tsx+++ b/skyvern-frontend/src/routes/workflows/studio/StudioTopBar.tsx@@ -132,7 +132,10 @@ function PanelToggle({);}-export function RunStopButton() {+// stopOnly: global (read-only) workflows can't start runs from the studio, but+// runs started elsewhere (e.g. the recipe pages run templates in place) still+// land here and must be stoppable — render Stop when active, nothing otherwise.+export function RunStopButton({ stopOnly = false }: { stopOnly?: boolean }) {const navigate = useNavigate();const { workflowPermanentId } = useParams();const runId = useStudioRunId();@@ -225,7 +228,7 @@ export function RunStopButton() {</DialogContent></Dialog>);- if (!isBlockRun) {+ if (stopOnly || !isBlockRun) {return stopDialog;}return (@@ -263,6 +266,9 @@ export function RunStopButton() {</>);}+ if (stopOnly) {+ return null;+ }return (<Buttonsize="default"@@ -303,7 +309,10 @@ export function StudioTopBar() {Agent deleted on {basicLocalTimeFormat(workflowDeletedAt)}</span>) : isGlobalWorkflow ? (- <MakeACopyButton />+ <div className="flex items-center gap-2">+ <RunStopButton stopOnly />+ <MakeACopyButton />+ </div>) : (<div data-tour="editor-actions" className="flex items-center gap-2"><div className="flex items-center gap-1">diff --git a/skyvern/exceptions.py b/skyvern/exceptions.pyindex 5e26d2413..f5e816166 100644--- a/skyvern/exceptions.py+++ b/skyvern/exceptions.py@@ -171,6 +171,16 @@ class PhoneNumberInputMismatch(SkyvernException):)+class CardNumberInputMismatch(SkyvernException):+ def __init__(self, *, expected_digit_count: int, actual_digit_count: int):+ self.expected_digit_count = expected_digit_count+ self.actual_digit_count = actual_digit_count+ super().__init__(+ "Card number input read-back mismatch: "+ f"expected {expected_digit_count} digits, found {actual_digit_count} digits."+ )++class ConditionalBranchEvaluationError(SkyvernException):"""A conditional block could not resolve which branch to take."""diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.pyindex ff9d7ab35..5bf18746c 100644--- a/skyvern/webeye/actions/handler.py+++ b/skyvern/webeye/actions/handler.py@@ -31,6 +31,7 @@ from skyvern.constants import (from skyvern.core.script_generations.fuzzy_matcher import match_option_exact_or_stemfrom skyvern.errors.errors import TOTPExpiredError, UserDefinedError, filter_to_user_defined_codesfrom skyvern.exceptions import (+ CardNumberInputMismatch,EmptySelect,ErrEmptyTweakValue,ErrFoundSelectableElement,@@ -1196,6 +1197,122 @@ async def _verify_tel_input_after_fill(*, skyvern_element: SkyvernElement, tag_n)+_CARD_NUMBER_MIN_DIGITS = 13+_CARD_NUMBER_MAX_DIGITS = 19+++def _card_number_digits(value: str | None) -> str:+ return re.sub(r"\D", "", value or "")+++def _luhn_valid(digits: str) -> bool:+ total = 0+ for index, char in enumerate(reversed(digits)):+ digit = ord(char) - ord("0")+ if index % 2 == 1:+ digit *= 2+ if digit > 9:+ digit -= 9+ total += digit+ return total % 10 == 0+++def _is_probable_card_number(digits: str) -> bool:+ # A bare digit string that is card-length (13-19) and Luhn-valid. Luhn plus length is a strong,+ # self-limiting gate: phone numbers, order IDs, and free text almost never satisfy both, so the+ # read-back path stays off non-card fields.+ if not (_CARD_NUMBER_MIN_DIGITS <= len(digits) <= _CARD_NUMBER_MAX_DIGITS):+ return False+ return _luhn_valid(digits)+++def _has_card_number_token(value: str | None) -> bool:+ # Lower-case first, then drop all separators, so camelCase and unseparated forms match too:+ # "card.number" / "card_number" / "cardNumber" / "cardnumber" / "cc-number" all count, while+ # "number" / "phone" / "cardholder" do not.+ normalized = re.sub(r"[^a-z0-9]", "", (value or "").lower())+ return "cardnumber" in normalized or "ccnumber" in normalized+++_CARD_READBACK_SEPARATORS = r"[\s\-./]"+++def _readable_card_digits(actual_value: str | None) -> str | None:+ # The rendered value reduced to a clean ASCII digit string, or None when it cannot be compared+ # (empty, masked with bullets/asterisks, or non-digit after stripping common group separators).+ # Python \s covers NBSP, which some auto-formatters emit between groups.+ if not actual_value:+ return None+ stripped = re.sub(_CARD_READBACK_SEPARATORS, "", actual_value)+ if not (stripped.isascii() and stripped.isdigit()):+ return None+ return stripped+++def _card_readback_is_mismatch(expected_digits: str, actual_value: str | None) -> bool:+ # True only when the rendered value is a clean digit string that differs from the expected card+ # digits. An unreadable read-back (empty/masked) is not a mismatch: before clearing, the field is+ # left as typed rather than risking a wrong retype on a field we cannot read.+ actual_digits = _readable_card_digits(actual_value)+ return actual_digits is not None and actual_digits != expected_digits+++def _card_readback_matches(expected_digits: str, actual_value: str | None) -> bool:+ # True only on a positive digit match. Used after clearing a known-bad value and atomically+ # re-entering it: success must be positively confirmed, so an unreadable/masked/mismatched retry+ # read-back is NOT a match and forces a loud failure rather than a silent wrong card.+ return _readable_card_digits(actual_value) == expected_digits+++async def _is_card_number_field(skyvern_element: SkyvernElement) -> bool:+ # Deterministic, live-attr detection of a card-number field: an explicit cc-number autocomplete+ # token, or a numeric-only field. Paired with a Luhn-valid 13-19 digit value at the call site,+ # this stays off phone numbers, quantities, and other numeric inputs.+ autocomplete = (await skyvern_element.get_attr("autocomplete") or "").lower()+ if "cc-number" in autocomplete:+ return True+ for attr_name in ("name", "id"):+ if _has_card_number_token(await skyvern_element.get_attr(attr_name)):+ return True+ inputmode = (await skyvern_element.get_attr("inputmode") or "").lower()+ return inputmode == "numeric"+++async def _fill_card_number_with_readback(+ *, skyvern_element: SkyvernElement, tag_name: str, text: str, expected_digits: str+) -> ActionFailure | None:+ # Type the card number, then read the rendered digits back. Character-by-character typing races an+ # auto-formatting field's caret restore and can scramble the value (SKY-11720); a single atomic+ # value-set formats once, without the race, so a mismatch is re-entered atomically before failing.+ await skyvern_element.input_sequentially(text=text)+ actual_value = await get_input_value(tag_name=tag_name, locator=skyvern_element.get_locator())+ if not _card_readback_is_mismatch(expected_digits, actual_value):+ return None++ await skyvern_element.input_clear()+ await skyvern_element.input_fill(text=text)+ actual_value = await get_input_value(tag_name=tag_name, locator=skyvern_element.get_locator())+ # Success after re-entry must be positively confirmed: a clean digit match. An empty/masked/+ # unreadable or still-mismatched retry read-back is NOT success -- fail loudly rather than silently+ # proceed with a value we deleted-and-could-not-verify.+ if _card_readback_matches(expected_digits, actual_value):+ return None++ actual_digits = _card_number_digits(actual_value)+ LOG.warning(+ "Card number read-back mismatch after retry",+ element_id=skyvern_element.get_id(),+ expected_digit_count=len(expected_digits),+ actual_digit_count=len(actual_digits),+ )+ return ActionFailure(+ CardNumberInputMismatch(+ expected_digit_count=len(expected_digits),+ actual_digit_count=len(actual_digits),+ )+ )++def _select_option_target_value(option: SelectOption) -> str | None:if option.label:return option.label@@ -2987,9 +3104,13 @@ async def handle_input_text_action(return [ActionFailure(InputToReadonlyElement(element_id=skyvern_element.get_id()))]is_tel = await skyvern_element.get_attr("type") == "tel"+ candidate_card_digits = _card_number_digits(text)+ is_card_number_input = _is_probable_card_number(candidate_card_digits) and await _is_card_number_field(+ skyvern_element+ )is_plain_nanp_tel = Falserun_phone_format_check = False- if is_tel and await _is_tel_digit_fix_enabled(task):+ if is_tel and not is_card_number_input and await _is_tel_digit_fix_enabled(task):# SKY-11315 fix, behind FIX_TEL_INPUT_DIGIT_DROP. Flag-off keeps the original behavior below# byte-for-byte. Plain-NANP tel is typed as bare digits (skipping the format-check LLM) unless# the field's pattern requires a mask; secrets are eligible (local strip, no LLM).@@ -2997,7 +3118,7 @@ async def handle_input_text_action(text, is_plain_nanp_tel, run_phone_format_check = _plan_tel_text(is_tel=True, is_secret=is_secret_value, value=text, pattern=tel_pattern)- elif is_tel and not is_secret_value:+ elif is_tel and not is_card_number_input and not is_secret_value:run_phone_format_check = Trueif run_phone_format_check:try:@@ -3161,37 +3282,56 @@ async def handle_input_text_action(# Only the bare-digit NANP fill is read back to verify; other tel shapes are left unverified.verify_tel_input_after_fill = is_plain_nanp_tel+ # SKY-11720: an auto-formatting card-number field (a space every 4 digits) restores its caret+ # naively, racing character-by-character entry so the rendered value can silently differ from+ # the provided card while the block still completes. Deterministic card-number read-back runs+ # only when the value is Luhn-valid 13-19 digits and live field attrs identify a card-like+ # numeric field; mismatches are re-entered atomically before failing loudly.+ card_expected_digits = ""+ if is_card_number_input:+ card_expected_digits = candidate_card_digits+await incremental_scraped.start_listen_dom_increment(await skyvern_element.get_element_handler())try:- await skyvern_element.input_sequentially(text=text)- if verify_tel_input_after_fill:- # Read the typed digits back; on mismatch, clear and retype once. A second mismatch- # fails the action here rather than letting it surface as a silent wrong fill.- try:- await _verify_tel_input_after_fill(- skyvern_element=skyvern_element,- tag_name=tag_name,- expected_value=text,- )- except PhoneNumberInputMismatch:- await skyvern_element.input_clear()- await skyvern_element.input_sequentially(text=text)+ if card_expected_digits:+ card_failure = await _fill_card_number_with_readback(+ skyvern_element=skyvern_element,+ tag_name=tag_name,+ text=text,+ expected_digits=card_expected_digits,+ )+ if card_failure is not None:+ return [card_failure]+ else:+ await skyvern_element.input_sequentially(text=text)+ if verify_tel_input_after_fill:+ # Read the typed digits back; on mismatch, clear and retype once. A second mismatch+ # fails the action here rather than letting it surface as a silent wrong fill.try:await _verify_tel_input_after_fill(skyvern_element=skyvern_element,tag_name=tag_name,expected_value=text,)- except PhoneNumberInputMismatch as mismatch:- LOG.warning(- "Phone input read-back mismatch after retry",- action=action,- element_id=skyvern_element.get_id(),- expected_digit_count=mismatch.expected_digit_count,- actual_digit_count=mismatch.actual_digit_count,- )- return [ActionFailure(mismatch)]+ except PhoneNumberInputMismatch:+ await skyvern_element.input_clear()+ await skyvern_element.input_sequentially(text=text)+ try:+ await _verify_tel_input_after_fill(+ skyvern_element=skyvern_element,+ tag_name=tag_name,+ expected_value=text,+ )+ except PhoneNumberInputMismatch as mismatch:+ LOG.warning(+ "Phone input read-back mismatch after retry",+ action=action,+ element_id=skyvern_element.get_id(),+ expected_digit_count=mismatch.expected_digit_count,+ actual_digit_count=mismatch.actual_digit_count,+ )+ return [ActionFailure(mismatch)]incremental_element = await incremental_scraped.get_incremental_element_tree(clean_and_remove_element_tree_factory(diff --git a/tests/unit/test_cc_input_digit_drop.py b/tests/unit/test_cc_input_digit_drop.pynew file mode 100644index 000000000..be6ee8ac7--- /dev/null+++ b/tests/unit/test_cc_input_digit_drop.py@@ -0,0 +1,223 @@+from __future__ import annotations++from unittest.mock import AsyncMock, MagicMock++import pytest++from skyvern.webeye.actions.handler import (+ _card_readback_is_mismatch,+ _card_readback_matches,+ _fill_card_number_with_readback,+ _has_card_number_token,+ _is_card_number_field,+ _is_probable_card_number,+)+from skyvern.webeye.actions.responses import ActionFailure++# Reserved Luhn-valid test PANs (no real cardholder data).+VISA_16 = "4539578763621486"+AMEX_15 = "378282246310005"+++ "digits,expected",+ [+ (VISA_16, True), # 16-digit Visa, Luhn ok+ (AMEX_15, True), # 15-digit Amex, Luhn ok+ ("4111111111111111", True), # 16-digit test Visa, Luhn ok+ ("4917484589897107", True), # 16-digit, Luhn ok+ ("4539578763621487", False), # 16 digits, Luhn fails (last digit off)+ ("2245550199", False), # 10-digit phone number, not card-length+ ("123456789012", False), # 12 digits, below the card floor+ ("12345678901234567890", False), # 20 digits, above the card ceiling+ ("", False),+ ],+)+def test_is_probable_card_number(digits: str, expected: bool) -> None:+ assert _is_probable_card_number(digits) is expected+++ "actual_value,is_mismatch",+ [+ ("4539 5787 6362 1486", False), # correct digits, formatted -> match+ ("4539578763621486", False), # correct digits, unformatted -> match+ ("4539 5876 6214 6837", True), # same length, scrambled digits -> mismatch+ ("4539 5787 6362 148", True), # a digit dropped -> mismatch+ ("•••• •••• •••• 1486", False), # masked read-back, cannot compare -> not a mismatch+ ("4539 88XX XXXX 1486", False), # partially masked with letters -> not a mismatch+ ("", False), # empty read-back -> not a mismatch+ (None, False), # unreadable -> not a mismatch+ ("4539.5787.6362.1486", False), # dot-formatted correct -> match+ ("4539.5876.6214.6837", True), # dot-formatted scramble -> mismatch (separator-class fix)+ ("4539/5876/6214/6837", True), # slash-formatted scramble -> mismatch+ ("4539\xa05787\xa06362\xa01486", False), # NBSP-formatted correct -> match+ ("4539.5787.6362.148", True), # dot-formatted dropped digit -> still mismatch+ ],+)+def test_card_readback_is_mismatch(actual_value: str | None, is_mismatch: bool) -> None:+ assert _card_readback_is_mismatch(VISA_16, actual_value) is is_mismatch+++ "actual_value,matches",+ [+ ("4539 5787 6362 1486", True), # correct, space-formatted+ ("4539.5787.6362.1486", True), # correct, dot-formatted+ ("4539\xa05787\xa06362\xa01486", True), # correct, NBSP-formatted+ ("4539578763621486", True), # correct, unformatted+ ("4539 5876 6214 6837", False), # scrambled -> not a positive match+ ("4539 5787 6362 148", False), # dropped digit -> not a positive match+ ("•••• •••• •••• 1486", False), # masked -> not a positive match+ ("", False), # empty -> not a positive match+ (None, False), # unreadable -> not a positive match+ ],+)+def test_card_readback_matches(actual_value: str | None, matches: bool) -> None:+ assert _card_readback_matches(VISA_16, actual_value) is matches+++def _make_card_element(readbacks: list[str | None]) -> MagicMock:+ locator = MagicMock()+ locator.input_value = AsyncMock(side_effect=list(readbacks))+ element = MagicMock()+ element.get_locator = MagicMock(return_value=locator)+ element.get_id = MagicMock(return_value="card")+ element.input_sequentially = AsyncMock()+ element.input_clear = AsyncMock()+ element.input_fill = AsyncMock()+ return element+++async def test_fill_card_number_recovers_scramble_with_atomic_fill() -> None:+ # First (character-by-character) fill scrambles the digits; the atomic re-entry renders them+ # correctly, so the helper recovers with no failure.+ element = _make_card_element(["4539 5876 6214 6837", "4539 5787 6362 1486"])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert result is None+ element.input_sequentially.assert_awaited_once_with(text=VISA_16)+ element.input_clear.assert_awaited_once()+ element.input_fill.assert_awaited_once_with(text=VISA_16)+++async def test_fill_card_number_clean_first_try_skips_retry() -> None:+ element = _make_card_element(["4539 5787 6362 1486"])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert result is None+ element.input_clear.assert_not_awaited()+ element.input_fill.assert_not_awaited()+++async def test_fill_card_number_fails_after_second_mismatch() -> None:+ element = _make_card_element(["4539 5876 6214 6837", "4539 5876 6214 6837"])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert isinstance(result, ActionFailure)+ assert result.success is False+ assert result.exception_type == "CardNumberInputMismatch"+ element.input_fill.assert_awaited_once_with(text=VISA_16)+++async def test_fill_card_number_masked_readback_does_not_retype() -> None:+ # A masked field cannot be read back, so the helper must not clear/retype a possibly-correct value.+ element = _make_card_element(["•••• •••• •••• 1486"])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert result is None+ element.input_clear.assert_not_awaited()+ element.input_fill.assert_not_awaited()+++async def test_fill_card_number_fails_when_retry_readback_empty() -> None:+ # After a confirmed first mismatch we cleared a known-bad value; if the retry read-back is empty+ # (fill rejected/async-cleared) success must NOT be assumed -- fail loudly instead of silently+ # proceeding with an unverified card.+ element = _make_card_element(["4539 5876 6214 6837", ""])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert isinstance(result, ActionFailure)+ assert result.exception_type == "CardNumberInputMismatch"+ element.input_fill.assert_awaited_once_with(text=VISA_16)+++async def test_fill_card_number_fails_when_retry_readback_masked() -> None:+ # Same guarantee when the retry read-back is masked/unreadable: a positive digit match is required.+ element = _make_card_element(["4539 5876 6214 6837", "•••• •••• •••• 1486"])++ result = await _fill_card_number_with_readback(+ skyvern_element=element, tag_name="input", text=VISA_16, expected_digits=VISA_16+ )++ assert isinstance(result, ActionFailure)+ assert result.exception_type == "CardNumberInputMismatch"+ element.input_fill.assert_awaited_once_with(text=VISA_16)+++ "attrs,expected",+ [+ ({"autocomplete": "cc-number"}, True), # explicit cc-number token+ ({"autocomplete": "section-billing cc-number"}, True), # compound autocomplete token+ ({"autocomplete": None, "name": "card.number"}, True), # hosted checkout tel card field+ ({"autocomplete": None, "id": "card-number"}, True), # card-number id token+ ({"autocomplete": None, "name": "cardNumber"}, True), # camelCase name (unseparated + mixed case)+ ({"autocomplete": None, "id": "cardnumber"}, True), # unseparated id token+ ({"autocomplete": None, "name": "cc-number"}, True), # cc-number as a name/id+ ({"autocomplete": None, "inputmode": "numeric"}, True), # numeric-only field+ ({"autocomplete": "off", "inputmode": "numeric"}, True), # numeric wins over autocomplete=off+ ({"autocomplete": None, "name": "phone", "inputmode": "tel"}, False), # phone field is not a card field+ ({"autocomplete": None, "name": "cardholder"}, False), # cardholder is not a card-number field+ ({"autocomplete": "email", "inputmode": "text"}, False), # neither signal+ ({"autocomplete": None, "inputmode": None}, False), # no signals+ ],+)+async def test_is_card_number_field(attrs: dict[str, str | None], expected: bool) -> None:+ element = MagicMock()+ element.get_attr = AsyncMock(side_effect=lambda name, **kwargs: attrs.get(name))+ assert await _is_card_number_field(element) is expected+++ "value,expected",+ [+ ("card.number", True), # dot separator+ ("card-number", True), # dash separator+ ("card_number", True), # underscore separator+ ("cardNumber", True), # camelCase, unseparated+ ("cardnumber", True), # unseparated lowercase+ ("CardNumber", True), # unseparated mixed case+ ("cc-number", True), # cc-number form+ ("ccNumber", True), # cc camelCase+ ("number", False), # bare "number" is not enough+ ("phone", False),+ ("cardholder", False), # card, but not a card *number*+ ("", False),+ (None, False),+ ],+)+def test_has_card_number_token(value: str | None, expected: bool) -> None:+ assert _has_card_number_token(value) is expecteddiff --git a/tests/unit/test_input_text_tel_card_routing.py b/tests/unit/test_input_text_tel_card_routing.pynew file mode 100644index 000000000..5050cd677--- /dev/null+++ b/tests/unit/test_input_text_tel_card_routing.py@@ -0,0 +1,126 @@+from __future__ import annotations++from datetime import UTC, datetime+from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from skyvern.forge.sdk.models import StepStatus+from skyvern.webeye.actions.actions import InputTextAction+from skyvern.webeye.actions.handler import handle_input_text_action+from skyvern.webeye.actions.responses import ActionSuccess+from tests.unit.helpers import make_organization, make_step, make_task++_NOW = datetime.now(UTC)+_ORG = make_organization(_NOW)+_TASK = make_task(_NOW, _ORG, navigation_payload={}, navigation_goal="Fill checkout contact fields")+_STEP = make_step(_NOW, _TASK, step_id="stp-tel-card-routing", status=StepStatus.created, order=0, output=None)++VISA_16 = "4539578763621486"+++def _mock_input(attrs: dict[str, str | None]) -> MagicMock:+ el = MagicMock()+ el.get_id.return_value = "AADC"+ el.get_tag_name.return_value = "input"+ el.get_frame.return_value = MagicMock()+ locator = MagicMock()+ locator.focus = AsyncMock()+ el.get_locator.return_value = locator+ el.is_disabled = AsyncMock(return_value=False)+ el.get_selectable = AsyncMock(return_value=False)+ el.has_hidden_attr = AsyncMock(return_value=False)+ el.is_readonly = AsyncMock(return_value=False)+ el.get_attr = AsyncMock(side_effect=lambda name, **kwargs: attrs.get(name))+ el.is_spinbtn_input = AsyncMock(return_value=False)+ el.is_editable = AsyncMock(return_value=True)+ el.is_visible = AsyncMock(return_value=True)+ el.is_raw_input = AsyncMock(return_value=True)+ el.supports_text_input = AsyncMock(return_value=True)+ el.find_blocking_element = AsyncMock(return_value=(None, False))+ el.get_element_handler = AsyncMock(return_value=MagicMock())+ el.input_sequentially = AsyncMock()+ el.input_clear = AsyncMock()+ el.input_fill = AsyncMock()+ el.press_key = AsyncMock()+ return el+++async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, AsyncMock, AsyncMock]:+ dom_instance = MagicMock()+ dom_instance.get_skyvern_element_by_id = AsyncMock(return_value=el)++ inc = MagicMock()+ inc.start_listen_dom_increment = AsyncMock()+ inc.stop_listen_dom_increment = AsyncMock()+ inc.get_incremental_element_tree = AsyncMock(return_value=[])++ skyvern_frame = MagicMock()+ skyvern_frame.safe_wait_for_animation_end = AsyncMock()++ scraped_page = MagicMock()+ scraped_page.id_to_element_dict = {"AADC": {"tagName": "input"}}++ card_readback = AsyncMock(return_value=None)+ tel_verify = AsyncMock()+ phone_format = AsyncMock(return_value=text)++ with (+ patch("skyvern.webeye.actions.handler.DomUtil", return_value=dom_instance),+ patch("skyvern.webeye.actions.handler.SkyvernFrame.create_instance", new=AsyncMock(return_value=skyvern_frame)),+ patch("skyvern.webeye.actions.handler.IncrementalScrapePage", return_value=inc),+ patch("skyvern.webeye.actions.handler.get_input_value", new=AsyncMock(return_value="")),+ patch("skyvern.webeye.actions.handler.get_actual_value_of_parameter_if_secret_with_task", return_value=text),+ patch("skyvern.webeye.actions.handler._get_input_or_select_context", new=AsyncMock(return_value=None)),+ patch("skyvern.webeye.actions.handler._is_tel_digit_fix_enabled", new=AsyncMock(return_value=True)),+ patch("skyvern.webeye.actions.handler.check_phone_number_format", new=phone_format),+ patch("skyvern.webeye.actions.handler._fill_card_number_with_readback", new=card_readback),+ patch("skyvern.webeye.actions.handler._verify_tel_input_after_fill", new=tel_verify),+ ):+ results = await handle_input_text_action(+ action=InputTextAction(element_id="AADC", text=text, reasoning="fill field"),+ page=MagicMock(),+ scraped_page=scraped_page,+ task=_TASK,+ step=_STEP,+ )++ return results, card_readback, tel_verify, phone_format+++ "attrs",+ [+ {"type": "tel", "autocomplete": "cc-number", "name": None},+ {"type": "tel", "autocomplete": None, "name": "card.number"},+ ],+)+async def test_tel_card_number_field_uses_card_readback_not_phone_format(attrs: dict[str, str | None]) -> None:+ el = _mock_input(attrs)++ results, card_readback, tel_verify, phone_format = await _run_input_text(el, VISA_16)++ assert len(results) == 1 and isinstance(results[0], ActionSuccess)+ card_readback.assert_awaited_once_with(+ skyvern_element=el,+ tag_name="input",+ text=VISA_16,+ expected_digits=VISA_16,+ )+ phone_format.assert_not_awaited()+ tel_verify.assert_not_awaited()+ el.input_sequentially.assert_not_awaited()+++async def test_ten_digit_tel_phone_uses_tel_readback_not_card_readback() -> None:+ el = _mock_input({"type": "tel", "autocomplete": None, "name": "phone"})++ results, card_readback, tel_verify, phone_format = await _run_input_text(el, "224-555-0199")++ assert len(results) == 1 and isinstance(results[0], ActionSuccess)+ el.input_sequentially.assert_awaited_once_with(text="2245550199")+ tel_verify.assert_awaited_once_with(skyvern_element=el, tag_name="input", expected_value="2245550199")+ card_readback.assert_not_awaited()+ phone_format.assert_not_awaited()