Skip to content

Automate browser based workflows with AI

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.tsx
index 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>
<Route
path="/workflows/:workflowPermanentId/studio"
- element={<RunStopButton />}
+ element={element}
/>
<Route
path="/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.tsx
index 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 (
<Button
size="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.py
index 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.py
index 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_stem
from skyvern.errors.errors import TOTPExpiredError, UserDefinedError, filter_to_user_defined_codes
from 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 = False
run_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 = True
if 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.py
new file mode 100644
index 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 expected
diff --git a/tests/unit/test_input_text_tel_card_routing.py b/tests/unit/test_input_text_tel_card_routing.py
new file mode 100644
index 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()