arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-05-05 16:39:08 +00:00
Code Issues Releases Wiki Activity

refactor(tests): split buttons module functionality into buttons and actions

Browse Source
This commit is contained in:
Lukas Bielesch 2025-03-07 12:43:16 +01:00 committed by Lukáš Bielesch
parent 4d52f7805f
commit a4cd4ddaa5
17 changed files with 555 additions and 439 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

388
tests/buttons.py
View File

@ -6,167 +6,227 @@ from trezorlib.debuglink import LayoutType
Coords = Tuple[int, int]
# display dimensions
def display_height(layout_type):
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
class ScreenButtons:
def __init__(self, layout_type: LayoutType):
assert layout_type in (LayoutType.Bolt, LayoutType.Delizia)
self.layout_type = layout_type
def _width(self) -> int:
return 240
else:
raise ValueError("Wrong layout type")
def display_width(layout_type):
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
def _height(self) -> int:
return 240
else:
raise ValueError("Wrong layout type")
def _grid(self, dim: int, grid_cells: int, cell: int) -> int:
assert cell < grid_cells
step = dim // grid_cells
ofs = step // 2
return cell * step + ofs
# grid coordinates
def grid(dim: int, grid_cells: int, cell: int) -> int:
step = dim // grid_cells
ofs = step // 2
return cell * step + ofs
# 3 columns, 4 rows, 1st row is input area
def _grid35(self, x: int, y: int) -> Coords:
return self._grid(self._width(), 3, x), self._grid(self._height(), 5, y)
# TODO: do not expose this
# 3 columns, 3 rows, 1st row is input area
def grid34(self, x: int, y: int) -> Coords:
return self._grid(self._width(), 3, x), self._grid(self._height(), 4, y)
def grid35(x: int, y: int, layout_type: LayoutType) -> Coords:
return grid(display_width(layout_type), 3, x), grid(
display_height(layout_type), 5, y
)
# Horizontal coordinates
def _left(self) -> int:
return self._grid(self._width(), 3, 0)
def _mid(self) -> int:
return self._grid(self._width(), 3, 1)
def grid34(x: int, y: int, layout_type: LayoutType) -> Coords:
assert layout_type in (LayoutType.Bolt, LayoutType.Delizia)
return grid(display_width(layout_type), 3, x), grid(
display_height(layout_type), 4, y
)
def _right(self) -> int:
return self._grid(self._width(), 3, 2)
# Vertical coordinates
def _top(self) -> int:
return self._grid(self._height(), 6, 0)
def _grid34_from_index(idx: int, layout_type: LayoutType) -> Coords:
grid_x = idx % 3
grid_y = idx // 3 + 1 # first line is empty
return grid34(grid_x, grid_y, layout_type)
def _bottom(self) -> int:
return self._grid(self._height(), 6, 5)
# Buttons
# Horizontal coordinates
def left(layout_type: LayoutType):
return grid(display_width(layout_type), 3, 0)
# Right bottom
def ok(self) -> Coords:
return (self._right(), self._bottom())
# Left bottom
def cancel(self) -> Coords:
return (self._left(), self._bottom())
def mid(layout_type: LayoutType):
return grid(display_width(layout_type), 3, 1)
# Mid bottom
def info(self) -> Coords:
return (self._mid(), self._bottom())
# Menu/close menu button
def menu(self) -> Coords:
if self.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return (215, 25)
else:
raise ValueError("Wrong layout type")
def right(layout_type: LayoutType):
return grid(display_width(layout_type), 3, 2)
# Center of the screen
def tap_to_confirm(self) -> Coords:
assert self.layout_type is LayoutType.Delizia
return (self._grid(self._width(), 1, 0), self._grid(self._width(), 1, 0))
# Yes/No decision component
def ui_yes(self) -> Coords:
assert self.layout_type is LayoutType.Delizia
return self.grid34(2, 2)
# Vertical coordinates
def top(layout_type: LayoutType):
return grid(display_height(layout_type), 6, 0)
def ui_no(self) -> Coords:
assert self.layout_type is LayoutType.Delizia
return self.grid34(0, 2)
# +/- buttons in number input component
def number_input_minus(self) -> Coords:
if self.layout_type is LayoutType.Bolt:
return (self._left(), self._grid(self._height(), 5, 1))
elif self.layout_type is LayoutType.Delizia:
return (self._left(), self._grid(self._height(), 5, 3))
else:
raise ValueError("Wrong layout type")
def bottom(layout_type: LayoutType):
return grid(display_height(layout_type), 6, 5)
def number_input_plus(self) -> Coords:
if self.layout_type is LayoutType.Bolt:
return (self._right(), self._grid(self._height(), 5, 1))
elif self.layout_type is LayoutType.Delizia:
return (self._right(), self._grid(self._height(), 5, 3))
else:
raise ValueError("Wrong layout type")
def word_count_all_word(self, word_count: int) -> Coords:
assert word_count in (12, 18, 20, 24, 33)
if self.layout_type is LayoutType.Bolt:
coords_map = {
12: self.grid34(0, 2),
18: self.grid34(1, 2),
20: self.grid34(2, 2),
24: self.grid34(1, 3),
33: self.grid34(2, 3),
}
elif self.layout_type is LayoutType.Delizia:
coords_map = {
12: self.grid34(0, 1),
18: self.grid34(2, 1),
20: self.grid34(0, 2),
24: self.grid34(2, 2),
33: self.grid34(2, 3),
}
else:
raise ValueError("Wrong layout type")
# Buttons
return coords_map[word_count]
def word_count_all_cancel(self) -> Coords:
if self.layout_type is LayoutType.Bolt:
return self.grid34(0, 3)
def ok(layout_type: LayoutType) -> Coords:
return (right(layout_type), bottom(layout_type))
elif self.layout_type is LayoutType.Delizia:
return self.grid34(0, 3)
else:
raise ValueError("Wrong layout type")
def cancel(layout_type: LayoutType) -> Coords:
return (left(layout_type), bottom(layout_type))
def word_count_repeated_word(self, word_count: int) -> Coords:
assert word_count in (20, 33)
if self.layout_type is LayoutType.Bolt:
coords_map = {
20: self.grid34(1, 2),
33: self.grid34(2, 2),
}
elif self.layout_type is LayoutType.Delizia:
coords_map = {
20: self.grid34(0, 1),
33: self.grid34(2, 1),
}
else:
raise ValueError("Wrong layout type")
return coords_map[word_count]
def info(layout_type: LayoutType) -> Coords:
return (mid(layout_type), bottom(layout_type))
def word_count_repeated_cancel(self) -> Coords:
if self.layout_type is LayoutType.Bolt:
return self.grid34(0, 2)
elif self.layout_type is LayoutType.Delizia:
return self.grid34(0, 3)
def recovery_delete(layout_type: LayoutType) -> Coords:
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return (left(layout_type), top(layout_type))
else:
raise ValueError("Wrong layout type")
else:
raise ValueError("Wrong layout type")
# select word component buttons
def word_check_words(self) -> "list[Coords]":
if self.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return [
(self._mid(), self._grid(self._height(), 5, 2)),
(self._mid(), self._grid(self._height(), 5, 3)),
(self._mid(), self._grid(self._height(), 5, 4)),
]
else:
raise ValueError("Wrong layout type")
def corner_button(layout_type: LayoutType) -> Coords:
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return (215, 25)
else:
raise ValueError("Wrong layout type")
# vertical menu buttons
def vertical_menu_items(self) -> "list[Coords]":
assert self.layout_type is LayoutType.Delizia
def confirm_word(layout_type: LayoutType) -> Coords:
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return (mid(layout_type), top(layout_type))
else:
raise ValueError("Wrong layout type")
# PIN/passphrase input
def input(layout_type: LayoutType) -> Coords:
return (mid(layout_type), top(layout_type))
# Yes/No decision component
def ui_yes(layout_type: LayoutType) -> Coords:
assert layout_type is LayoutType.Delizia
return grid34(2, 2, layout_type)
def ui_no(layout_type: LayoutType) -> Coords:
assert layout_type is LayoutType.Delizia
return grid34(0, 2, layout_type)
# +/- buttons in number input component
def reset_minus(layout_type: LayoutType) -> Coords:
if layout_type is LayoutType.Bolt:
return (left(layout_type), grid(display_height(layout_type), 5, 1))
elif layout_type is LayoutType.Delizia:
return (left(layout_type), grid(display_height(layout_type), 5, 3))
else:
raise ValueError("Wrong layout type")
def reset_plus(layout_type: LayoutType) -> Coords:
if layout_type is LayoutType.Bolt:
return (right(layout_type), grid(display_height(layout_type), 5, 1))
elif layout_type is LayoutType.Delizia:
return (right(layout_type), grid(display_height(layout_type), 5, 3))
else:
raise ValueError("Wrong layout type")
# select word component buttons
def reset_word_check(layout_type: LayoutType) -> Coords:
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return [
(mid(layout_type), grid(display_height(layout_type), 5, 2)),
(mid(layout_type), grid(display_height(layout_type), 5, 3)),
(mid(layout_type), grid(display_height(layout_type), 5, 4)),
(self._mid(), self._grid(self._height(), 4, 1)),
(self._mid(), self._grid(self._height(), 4, 2)),
(self._mid(), self._grid(self._height(), 4, 3)),
]
else:
raise ValueError("Wrong layout type")
# Pin/passphrase keyboards
def pin_passphrase_index(self, idx: int) -> Coords:
assert idx < 10
if idx == 9:
idx = 10 # last digit is in the middle
return self.pin_passphrase_grid(idx % 3, idx // 3)
# vertical menu buttons
def vertical_menu(layout_type: LayoutType) -> Coords:
if layout_type in (LayoutType.Bolt, LayoutType.Delizia):
return [
(mid(layout_type), grid(display_height(layout_type), 4, 1)),
(mid(layout_type), grid(display_height(layout_type), 4, 2)),
(mid(layout_type), grid(display_height(layout_type), 4, 3)),
]
else:
raise ValueError("Wrong layout type")
def pin_passphrase_grid(self, x: int, y: int) -> Coords:
assert x < 3, y < 4
y += 1 # first line is empty
return self._grid35(x, y)
# PIN/passphrase input
def pin_passphrase_input(self) -> Coords:
return (self._mid(), self._top())
def tap_to_confirm(layout_type: LayoutType) -> Coords:
assert layout_type is LayoutType.Delizia
return vertical_menu(layout_type)[1]
def pin_passphrase_erase(self) -> Coords:
return self.pin_passphrase_grid(0, 3)
def passphrase_confirm(self) -> Coords:
if self.layout_type is LayoutType.Bolt:
return self.pin_passphrase_grid(2, 3)
elif self.layout_type is LayoutType.Delizia:
return (215, 25)
else:
raise ValueError("Wrong layout type")
def pin_confirm(self) -> Coords:
return self.pin_passphrase_grid(2, 3)
# Mnemonic keyboard
def mnemonic_from_index(self, idx: int) -> Coords:
return self.mnemonic_grid(idx)
def mnemonic_grid(self, idx: int) -> Coords:
assert idx < 9
grid_x = idx % 3
grid_y = idx // 3 + 1 # first line is empty
return self.grid34(grid_x, grid_y)
def mnemonic_erase(self) -> Coords:
return (self._left(), self._top())
def mnemonic_confirm(self) -> Coords:
return (self._mid(), self._top())
BUTTON_LETTERS_BIP39 = ("abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz")
@ -194,57 +254,45 @@ def get_passphrase_choices(char: str) -> tuple[str, ...]:
return PASSPHRASE_SPECIAL
def passphrase(char: str, layout_type: LayoutType) -> Tuple[Coords, int]:
choices = get_passphrase_choices(char)
idx = next(i for i, letters in enumerate(choices) if char in letters)
click_amount = choices[idx].index(char) + 1
return pin_passphrase_index(idx, layout_type), click_amount
class ButtonActions:
def __init__(self, layout_type: LayoutType):
self.buttons = ScreenButtons(layout_type)
def passphrase(self, char: str) -> Tuple[Coords, int]:
choices = get_passphrase_choices(char)
idx = next(i for i, letters in enumerate(choices) if char in letters)
click_amount = choices[idx].index(char) + 1
return self.buttons.pin_passphrase_index(idx), click_amount
def pin_passphrase_index(idx: int, layout_type: LayoutType) -> Coords:
if idx == 9:
idx = 10 # last digit is in the middle
return pin_passphrase_grid(idx, layout_type)
def type_word(self, word: str, is_slip39: bool = False) -> Iterator[Coords]:
if is_slip39:
yield from self._type_word_slip39(word)
else:
yield from self._type_word_bip39(word)
def _type_word_slip39(self, word: str) -> Iterator[Coords]:
for l in word:
idx = next(
i for i, letters in enumerate(BUTTON_LETTERS_SLIP39) if l in letters
)
yield self.buttons.mnemonic_from_index(idx)
def pin_passphrase_grid(idx: int, layout_type: LayoutType) -> Coords:
grid_x = idx % 3
grid_y = idx // 3 + 1 # first line is empty
return grid35(grid_x, grid_y, layout_type)
def _type_word_bip39(self, word: str) -> Iterator[Coords]:
coords_prev: Coords | None = None
for letter in word:
time.sleep(0.1) # not being so quick to miss something
coords, amount = self._letter_coords_and_amount(letter)
# If the button is the same as for the previous letter,
# waiting a second before pressing it again.
if coords == coords_prev:
time.sleep(1.1)
coords_prev = coords
for _ in range(amount):
yield coords
def type_word(
word: str, layout_type: LayoutType, is_slip39: bool = False
) -> Iterator[Coords]:
if is_slip39:
yield from _type_word_slip39(word, layout_type)
else:
yield from _type_word_bip39(word, layout_type)
def _type_word_slip39(word: str, layout_type: LayoutType) -> Iterator[Coords]:
for l in word:
idx = next(i for i, letters in enumerate(BUTTON_LETTERS_SLIP39) if l in letters)
yield _grid34_from_index(idx, layout_type)
def _type_word_bip39(word: str, layout_type: LayoutType) -> Iterator[Coords]:
coords_prev: Coords | None = None
for letter in word:
time.sleep(0.1) # not being so quick to miss something
coords, amount = _letter_coords_and_amount(letter, layout_type)
# If the button is the same as for the previous letter,
# waiting a second before pressing it again.
if coords == coords_prev:
time.sleep(1.1)
coords_prev = coords
for _ in range(amount):
yield coords
def _letter_coords_and_amount(
letter: str, layout_type: LayoutType
) -> Tuple[Coords, int]:
idx = next(i for i, letters in enumerate(BUTTON_LETTERS_BIP39) if letter in letters)
click_amount = BUTTON_LETTERS_BIP39[idx].index(letter) + 1
return _grid34_from_index(idx, layout_type), click_amount
def _letter_coords_and_amount(self, letter: str) -> Tuple[Coords, int]:
idx = next(
i for i, letters in enumerate(BUTTON_LETTERS_BIP39) if letter in letters
)
click_amount = BUTTON_LETTERS_BIP39[idx].index(letter) + 1
return self.buttons.mnemonic_from_index(idx), click_amount

12
tests/click_tests/common.py
View File

@ -49,7 +49,8 @@ def get_char_category(char: str) -> PassphraseCategory:
def go_next(debug: "DebugLink") -> LayoutContent:
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Caesar:
debug.press_right()
elif debug.layout_type is LayoutType.Delizia:
@ -61,7 +62,8 @@ def go_next(debug: "DebugLink") -> LayoutContent:
def go_back(debug: "DebugLink", r_middle: bool = False) -> LayoutContent:
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(buttons.cancel(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.cancel())
elif debug.layout_type is LayoutType.Caesar:
if r_middle:
debug.press_middle()
@ -116,11 +118,13 @@ def _carousel_steps(current_index: int, wanted_index: int, length: int) -> int:
def unlock_gesture(debug: "DebugLink") -> LayoutContent:
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Caesar:
debug.press_right()
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.tap_to_confirm(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.tap_to_confirm())
else:
raise RuntimeError("Unknown model")
return debug.read_layout()

43
tests/click_tests/record_layout.py
View File

@ -91,7 +91,8 @@ CLICKS_HELP = """\
Type 'y' or just press Enter to click the right button (usually "OK")
Type 'n' to click the left button (usually "Cancel")
Type a digit (0-9) to click the appropriate button as if on a numpad.
Type 'g1,2' to click button in column 1 and row 2 of 3x5 grid (letter A on mnemonic keyboard).
Type 'm1,2' to click button in column 1 and row 2 of mnemonic keyboard (letter J).
Type 'p2,1' to click button in column 2 and row 1 of pin/passphrase keyboard (letter D).
Type 'i 1234' to send text "1234" without clicking (useful for PIN, passphrase, etc.)
Type 'u' or 'j' to swipe up, 'd' or 'k' to swipe down.
Type 'confirm' for hold-to-confirm (or a confirmation signal without clicking).
@ -138,29 +139,37 @@ def send_clicks(dest):
input_str = key[2:]
output = f"debug.input({input_str!r})"
DEBUGLINK.input(input_str)
elif key.startswith("g"):
elif key.startswith("m"):
x, y = [int(s) - 1 for s in key[1:].split(",")]
output = (
f"debug.click(buttons.grid35({x}, {y}, {DEBUGLINK.layout_type}))"
f"debug.click(ScreenButtons(layout_type).mnemonic_grid({x}, {y}))"
)
DEBUGLINK.click(
buttons.ScreenButtons(DEBUGLINK.layout_type).mnemonic_grid(x, y)
)
elif key.startswith("p"):
x, y = [int(s) - 1 for s in key[1:].split(",")]
output = f"debug.click(ScreenButtons(layout_type).pin_passphrase_grid({x}, {y}))"
DEBUGLINK.click(
buttons.ScreenButtons(DEBUGLINK.layout_type).pin_passphrase_grid(
x, y
)
)
DEBUGLINK.click(buttons.grid35(x, y, DEBUGLINK.layout_type))
elif key == "y":
output = "debug.click(buttons.ok(layout_type))"
DEBUGLINK.click(buttons.ok(DEBUGLINK.layout_type))
output = "debug.click(ScreenButtons(layout_type).ok())"
DEBUGLINK.click(buttons.ScreenButtons(DEBUGLINK.layout_type).ok())
elif key == "n":
output = "debug.click(buttons.cancel(layout_type))"
DEBUGLINK.click(buttons.cancel(DEBUGLINK.layout_type))
output = "debug.click(ScreenButtons(layout_type).cancel())"
DEBUGLINK.click(buttons.ScreenButtons(DEBUGLINK.layout_type).cancel())
elif key in "0123456789":
if key == "0":
x, y = 1, 4
else:
i = int(key) - 1
x = i % 3
y = 3 - (i // 3) # trust me
output = (
f"debug.click(buttons.grid35({x}, {y}, {DEBUGLINK.layout_type}))"
index = int(key)
output = f"debug.click(ScreenButtons(layout_type).pin_passphrase_index({index}))"
DEBUGLINK.click(
buttons.ScreenButtons(DEBUGLINK.layout_type).pin_passphrase_index(
index
)
)
DEBUGLINK.click(buttons.grid35(x, y, DEBUGLINK.layout_type))
elif key == "stop":
return
else:

84
tests/click_tests/recovery.py
View File

@ -17,15 +17,15 @@ def enter_word(
debug: "DebugLink", word: str, is_slip39: bool = False
) -> "LayoutContent":
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
btns = buttons.ScreenButtons(debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
typed_word = word[:4]
for coords in buttons.type_word(
typed_word, debug.layout_type, is_slip39=is_slip39
):
for coords in actions.type_word(typed_word, is_slip39=is_slip39):
debug.click(coords)
if debug.layout_type is LayoutType.Delizia and not is_slip39 and len(word) > 4:
# T3T1 (delizia) BIP39 keyboard allows to "confirm" only if the word is fully written, you need to click the word to auto-complete
debug.click(buttons.input(debug.layout_type))
debug.click(buttons.input(debug.layout_type))
debug.click(btns.mnemonic_confirm())
debug.click(btns.mnemonic_confirm())
return debug.read_layout()
elif debug.layout_type is LayoutType.Caesar:
letter_index = 0
@ -57,7 +57,8 @@ def confirm_recovery(debug: "DebugLink", title: str = "recovery__title") -> None
layout = debug.read_layout()
assert TR.translate(title) == layout.title()
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Delizia:
debug.swipe_up()
elif debug.layout_type is LayoutType.Caesar:
@ -70,12 +71,13 @@ def cancel_select_number_of_words(
unlock_repeated_backup=False,
) -> None:
if debug.layout_type is LayoutType.Bolt:
btns = buttons.ScreenButtons(debug.layout_type)
assert debug.read_layout().text_content() == TR.recovery__num_of_words
# click the button from ValuePad
if unlock_repeated_backup:
coords = buttons.grid34(0, 2, debug.layout_type)
coords = btns.word_count_repeated_cancel()
else:
coords = buttons.grid34(0, 3, debug.layout_type)
coords = btns.word_count_all_cancel()
debug.click(coords)
elif debug.layout_type is LayoutType.Caesar:
debug.press_right()
@ -84,8 +86,13 @@ def cancel_select_number_of_words(
# navigate to the number and confirm it
debug.press_left()
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
# click the button from ValuePad
debug.click(buttons.grid34(0, 3, debug.layout_type))
if unlock_repeated_backup:
coords = btns.word_count_repeated_cancel()
else:
coords = btns.word_count_all_cancel()
debug.click(coords)
else:
raise ValueError("Unknown model")
@ -99,23 +106,13 @@ def select_number_of_words(
assert TR.recovery__num_of_words in layout.text_content()
def select_bolt() -> "LayoutContent":
btns = buttons.ScreenButtons(debug.layout_type)
# click the button from ValuePad
if unlock_repeated_backup:
coords_map = {
20: buttons.grid34(1, 2, debug.layout_type),
33: buttons.grid34(2, 2, debug.layout_type),
}
coords = btns.word_count_repeated_word(num_of_words)
else:
coords_map = {
12: buttons.grid34(0, 2, debug.layout_type),
18: buttons.grid34(1, 2, debug.layout_type),
20: buttons.grid34(2, 2, debug.layout_type),
24: buttons.grid34(1, 3, debug.layout_type),
33: buttons.grid34(2, 3, debug.layout_type),
}
coords = coords_map.get(num_of_words)
if coords is None:
raise ValueError("Invalid num_of_words")
coords = btns.word_count_all_word(num_of_words)
debug.click(coords)
return debug.read_layout()
@ -129,23 +126,12 @@ def select_number_of_words(
return debug.read_layout()
def select_delizia() -> "LayoutContent":
btns = buttons.ScreenButtons(debug.layout_type)
# click the button from ValuePad
if unlock_repeated_backup:
coords_map = {
20: buttons.grid34(0, 1, debug.layout_type),
33: buttons.grid34(2, 1, debug.layout_type),
}
coords = btns.word_count_repeated_word(num_of_words)
else:
coords_map = {
12: buttons.grid34(0, 1, debug.layout_type),
18: buttons.grid34(2, 1, debug.layout_type),
20: buttons.grid34(0, 2, debug.layout_type),
24: buttons.grid34(2, 2, debug.layout_type),
33: buttons.grid34(2, 3, debug.layout_type),
}
coords = coords_map.get(num_of_words)
if coords is None:
raise ValueError("Invalid num_of_words")
coords = btns.word_count_all_word(num_of_words)
debug.click(coords)
return debug.read_layout()
@ -200,8 +186,9 @@ def enter_share(
debug.swipe_up()
layout = debug.read_layout()
else:
btns = buttons.ScreenButtons(debug.layout_type)
assert TR.translate(before_title) in debug.read_layout().title()
debug.click(buttons.ok(debug.layout_type))
debug.click(btns.ok())
layout = debug.read_layout()
assert "MnemonicKeyboard" in layout.all_components()
@ -276,9 +263,10 @@ def enter_seed_previous_correct(
if go_back:
go_back = False
if debug.layout_type is LayoutType.Bolt:
btns = buttons.ScreenButtons(debug.layout_type)
debug.swipe_right()
for _ in range(len(bad_word)):
debug.click(buttons.recovery_delete(debug.layout_type))
debug.click(btns.mnemonic_erase())
elif debug.layout_type is LayoutType.Caesar:
layout = debug.read_layout()
@ -295,9 +283,10 @@ def enter_seed_previous_correct(
debug.press_middle()
layout = debug.read_layout()
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.recovery_delete(debug.layout_type)) # Top-left
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.mnemonic_erase()) # Top-left
for _ in range(len(bad_word)):
debug.click(buttons.recovery_delete(debug.layout_type))
debug.click(btns.mnemonic_erase())
continue
if i in bad_indexes:
@ -322,7 +311,8 @@ def prepare_enter_seed(
or TR.translate(layout_text) in debug.read_layout().text_content()
)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Delizia:
debug.swipe_up()
debug.swipe_up()
@ -348,10 +338,11 @@ def cancel_recovery(debug: "DebugLink", recovery_type: str = "dry_run") -> None:
assert title in layout.title()
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.cancel(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.cancel())
layout = debug.read_layout()
assert cancel_title in layout.title()
debug.click(buttons.ok(debug.layout_type))
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Caesar:
debug.press_left()
layout = debug.read_layout()
@ -359,13 +350,14 @@ def cancel_recovery(debug: "DebugLink", recovery_type: str = "dry_run") -> None:
for _ in range(layout.page_count()):
debug.press_right()
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
# go to menu
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
layout = debug.read_layout()
assert (
TR.translate(f"recovery__cancel_{recovery_type}") in layout.text_content()
)
debug.click(buttons.vertical_menu(debug.layout_type)[0])
debug.click(btns.vertical_menu_items()[0])
else:
raise ValueError("Unknown model")

42
tests/click_tests/reset.py
View File

@ -15,10 +15,12 @@ if TYPE_CHECKING:
def confirm_new_wallet(debug: "DebugLink") -> None:
assert debug.read_layout().title() == TR.reset__title_create_wallet
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
debug.swipe_up()
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
elif debug.layout_type is LayoutType.Caesar:
debug.press_right()
debug.press_right()
@ -32,7 +34,8 @@ def confirm_new_wallet(debug: "DebugLink") -> None:
def confirm_read(debug: "DebugLink", middle_r: bool = False) -> None:
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Delizia:
debug.swipe_up()
elif debug.layout_type is LayoutType.Caesar:
@ -50,14 +53,16 @@ def cancel_backup(
debug: "DebugLink", middle_r: bool = False, confirm: bool = False
) -> None:
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.cancel(debug.layout_type))
debug.click(buttons.cancel(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.cancel())
debug.click(btns.cancel())
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.corner_button(debug.layout_type))
debug.click(buttons.vertical_menu(debug.layout_type)[0])
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.menu())
debug.click(btns.vertical_menu_items()[0])
if confirm:
debug.swipe_up()
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
elif debug.layout_type is LayoutType.Caesar:
debug.press_left()
debug.press_left()
@ -65,19 +70,16 @@ def cancel_backup(
def set_selection(debug: "DebugLink", diff: int) -> None:
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
btns = buttons.ScreenButtons(debug.layout_type)
assert "NumberInputDialog" in debug.read_layout().all_components()
button = (
buttons.reset_minus(debug.layout_type)
if diff < 0
else buttons.reset_plus(debug.layout_type)
)
button = btns.number_input_minus() if diff < 0 else btns.number_input_plus()
diff = abs(diff)
for _ in range(diff):
debug.click(button)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
debug.click(btns.ok())
else:
debug.swipe_up()
elif debug.layout_type is LayoutType.Caesar:
@ -123,9 +125,11 @@ def read_words(debug: "DebugLink", do_htc: bool = True) -> list[str]:
# There is hold-to-confirm button
if do_htc:
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type), hold_ms=1500)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok(), hold_ms=1500)
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.tap_to_confirm(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.tap_to_confirm())
elif debug.layout_type is LayoutType.Caesar:
debug.press_right(hold_ms=1200)
else:
@ -142,6 +146,7 @@ def confirm_words(debug: "DebugLink", words: list[str]) -> None:
layout = debug.read_layout()
if debug.layout_type is LayoutType.Bolt:
btns = buttons.ScreenButtons(debug.layout_type)
assert TR.regexp("reset__select_word_x_of_y_template").match(
layout.text_content()
)
@ -157,9 +162,10 @@ def confirm_words(debug: "DebugLink", words: list[str]) -> None:
]
wanted_word = words[word_pos - 1].lower()
button_pos = btn_texts.index(wanted_word)
debug.click(buttons.reset_word_check(debug.layout_type)[button_pos])
debug.click(btns.word_check_words()[button_pos])
layout = debug.read_layout()
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
assert TR.regexp("reset__select_word_x_of_y_template").match(layout.subtitle())
for _ in range(3):
# "Select word 3 of 20"
@ -173,7 +179,7 @@ def confirm_words(debug: "DebugLink", words: list[str]) -> None:
]
wanted_word = words[word_pos - 1].lower()
button_pos = btn_texts.index(wanted_word)
debug.click(buttons.vertical_menu(debug.layout_type)[button_pos])
debug.click(btns.vertical_menu_items()[button_pos])
layout = debug.read_layout()
elif debug.layout_type is LayoutType.Caesar:
assert TR.reset__select_correct_word in layout.text_content()

65
tests/click_tests/test_autolock.py
View File

@ -21,7 +21,7 @@ from typing import TYPE_CHECKING, Tuple
import pytest
from trezorlib import btc, device, exceptions, messages
from trezorlib.debuglink import LayoutType
from trezorlib.debuglink import DebugLink, LayoutType
from trezorlib.protobuf import MessageType
from trezorlib.tools import parse_path
@ -33,7 +33,7 @@ from . import recovery
from .common import go_next, unlock_gesture
if TYPE_CHECKING:
from trezorlib.debuglink import DebugLink, LayoutContent
from trezorlib.debuglink import LayoutContent
from ..device_handler import BackgroundDeviceHandler
@ -53,8 +53,17 @@ TXHASH_d5f65e = bytes.fromhex(
PIN4 = "1234"
def _center_button(layout_type: LayoutType) -> Tuple[int, int]:
return buttons.grid35(1, 2, layout_type)
def _passphrase_j(debug: DebugLink) -> Tuple[int, int]:
btns = buttons.ScreenButtons(debug.layout_type)
if debug.layout_type is LayoutType.Bolt:
return btns.pin_passphrase_grid(1, 1)
else:
return btns.pin_passphrase_grid(0, 1)
def _center_button(debug: DebugLink) -> Tuple[int, int]:
btns = buttons.ScreenButtons(debug.layout_type)
return btns.pin_passphrase_grid(1, 1)
def set_autolock_delay(device_handler: "BackgroundDeviceHandler", delay_ms: int):
@ -72,7 +81,8 @@ def set_autolock_delay(device_handler: "BackgroundDeviceHandler", delay_ms: int)
layout = go_next(debug)
if debug.layout_type is LayoutType.Delizia:
debug.click(buttons.tap_to_confirm(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.tap_to_confirm())
layout = debug.read_layout()
assert layout.main_component() == "Homescreen"
device_handler.result()
@ -107,8 +117,9 @@ def test_autolock_interrupts_signing(device_handler: "BackgroundDeviceHandler"):
)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
debug.click(btns.ok())
layout = debug.read_layout()
assert TR.send__total_amount in layout.text_content()
assert "0.0039 BTC" in layout.text_content()
@ -162,12 +173,14 @@ def test_autolock_does_not_interrupt_signing(device_handler: "BackgroundDeviceHa
)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
debug.click(btns.ok())
layout = debug.read_layout()
assert TR.send__total_amount in layout.text_content()
assert "0.0039 BTC" in layout.text_content()
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
debug.swipe_up()
debug.swipe_up()
layout = debug.read_layout()
@ -190,9 +203,9 @@ def test_autolock_does_not_interrupt_signing(device_handler: "BackgroundDeviceHa
device_handler.client.set_filter(messages.TxAck, sleepy_filter)
# confirm transaction
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
debug.click(btns.ok())
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
elif debug.layout_type is LayoutType.Caesar:
debug.press_middle()
@ -220,12 +233,9 @@ def test_autolock_passphrase_keyboard(device_handler: "BackgroundDeviceHandler")
# enter passphrase - slowly
# keep clicking for long enough to trigger the autolock if it incorrectly ignored key presses
for _ in range(math.ceil(11 / 1.5)):
if debug.layout_type is LayoutType.Bolt:
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
# click at "j"
debug.click(_center_button(debug.layout_type))
elif debug.layout_type is LayoutType.Delizia:
# click at "j"
debug.click((20, 120))
debug.click(_passphrase_j(debug))
elif debug.layout_type is LayoutType.Caesar:
# just go right
# NOTE: because of passphrase randomization it would be a pain to input
@ -234,10 +244,9 @@ def test_autolock_passphrase_keyboard(device_handler: "BackgroundDeviceHandler")
time.sleep(1.5)
# Send the passphrase to the client (TT has it clicked already, TR needs to input it)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
elif debug.layout_type is LayoutType.Delizia:
debug.click(buttons.corner_button(debug.layout_type))
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.passphrase_confirm())
elif debug.layout_type is LayoutType.Caesar:
debug.input("j" * 8)
@ -263,7 +272,7 @@ def test_autolock_interrupts_passphrase(device_handler: "BackgroundDeviceHandler
# autolock must activate even if we pressed some buttons
for _ in range(math.ceil(6 / 1.5)):
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(_center_button(debug.layout_type))
debug.click(_center_button(debug))
elif debug.layout_type is LayoutType.Caesar:
debug.press_middle()
time.sleep(1.5)
@ -359,29 +368,33 @@ def test_dryrun_enter_word_slowly(device_handler: "BackgroundDeviceHandler"):
recovery.select_number_of_words(debug, 20)
if debug.layout_type is LayoutType.Bolt:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
debug.click(btns.ok())
layout = debug.read_layout()
assert layout.main_component() == "MnemonicKeyboard"
# type the word OCEAN slowly
for coords in buttons.type_word("ocea", debug.layout_type, is_slip39=True):
for coords in actions.type_word("ocea", is_slip39=True):
time.sleep(9)
debug.click(coords)
debug.click(buttons.input(debug.layout_type))
debug.click(btns.mnemonic_confirm())
layout = debug.read_layout()
# should not have locked, even though we took 9 seconds to type each letter
assert layout.main_component() == "MnemonicKeyboard"
elif debug.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
debug.swipe_up()
layout = debug.read_layout()
assert layout.main_component() == "MnemonicKeyboard"
# type the word OCEAN slowly
for coords in buttons.type_word("ocea", debug.layout_type, is_slip39=True):
for coords in actions.type_word("ocea", is_slip39=True):
time.sleep(9)
debug.click(coords)
debug.click(buttons.input(debug.layout_type))
debug.click(btns.mnemonic_confirm())
layout = debug.read_layout()
# should not have locked, even though we took 9 seconds to type each letter
assert layout.main_component() == "MnemonicKeyboard"

3
tests/click_tests/test_lock.py
View File

@ -81,7 +81,8 @@ def test_hold_to_lock(device_handler: "BackgroundDeviceHandler"):
if debug.layout_type is LayoutType.Caesar:
debug.press_right()
else:
debug.click(buttons.info(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.info())
layout = debug.read_layout()
assert "PinKeyboard" in layout.all_components()
debug.input("1234")

16
tests/click_tests/test_passphrase_bolt.py
View File

@ -117,7 +117,8 @@ def press_char(debug: "DebugLink", char: str) -> None:
go_to_category(debug, char_category)
coords, amount = buttons.passphrase(char, debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
coords, amount = actions.passphrase(char)
# If the button is the same as for the previous char,
# waiting a second before pressing it again.
# (not for a space)
@ -141,13 +142,15 @@ def input_passphrase(debug: "DebugLink", passphrase: str, check: bool = True) ->
def enter_passphrase(debug: "DebugLink") -> None:
"""Enter a passphrase"""
coords = buttons.pin_passphrase_grid(11, debug.layout_type)
btns = buttons.ScreenButtons(debug.layout_type)
coords = btns.passphrase_confirm()
debug.click(coords)
def delete_char(debug: "DebugLink") -> None:
"""Deletes the last char"""
coords = buttons.pin_passphrase_grid(9, debug.layout_type)
btns = buttons.ScreenButtons(debug.layout_type)
coords = btns.pin_passphrase_erase()
debug.click(coords)
@ -216,8 +219,8 @@ def test_passphrase_loop_all_characters(device_handler: "BackgroundDeviceHandler
go_to_category(debug, category)
enter_passphrase(debug)
coords = buttons.pin_passphrase_grid(11, debug.layout_type)
debug.click(coords)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.passphrase_confirm())
@pytest.mark.setup_client(passphrase=True)
@ -225,7 +228,8 @@ def test_passphrase_click_same_button_many_times(
device_handler: "BackgroundDeviceHandler",
):
with prepare_passphrase_dialogue(device_handler) as debug:
a_coords, _ = buttons.passphrase("a", debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
a_coords, _ = actions.passphrase("a")
for _ in range(10):
debug.click(a_coords)

20
tests/click_tests/test_passphrase_delizia.py
View File

@ -87,10 +87,11 @@ def get_passphrase_choices(char: str) -> tuple[str, ...]:
def passphrase(char: str, layout_type: LayoutType) -> Tuple[buttons.Coords, int]:
btns = buttons.ScreenButtons(layout_type)
choices = get_passphrase_choices(char)
idx = next(i for i, letters in enumerate(choices) if char in letters)
click_amount = choices[idx].index(char) + 1
return buttons.pin_passphrase_index(idx, layout_type), click_amount
return btns.pin_passphrase_index(idx), click_amount
@contextmanager
@ -171,16 +172,16 @@ def input_passphrase(debug: "DebugLink", passphrase: str, check: bool = True) ->
def enter_passphrase(debug: "DebugLink") -> None:
"""Enter a passphrase"""
is_empty: bool = len(debug.read_layout().passphrase()) == 0
coords = buttons.corner_button(debug.layout_type) # top-right corner
debug.click(coords)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.passphrase_confirm())
if is_empty:
debug.click(buttons.ui_yes(debug.layout_type))
debug.click(btns.ui_yes())
def delete_char(debug: "DebugLink") -> None:
"""Deletes the last char"""
coords = buttons.pin_passphrase_grid(9, debug.layout_type)
debug.click(coords)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.pin_passphrase_erase())
VECTORS = ( # passphrase, address
@ -250,8 +251,8 @@ def test_passphrase_loop_all_characters(device_handler: "BackgroundDeviceHandler
debug.read_layout()
enter_passphrase(debug)
coords = buttons.pin_passphrase_grid(11, debug.layout_type)
debug.click(coords)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.passphrase_confirm())
@pytest.mark.setup_client(passphrase=True)
@ -259,7 +260,8 @@ def test_passphrase_click_same_button_many_times(
device_handler: "BackgroundDeviceHandler",
):
with prepare_passphrase_dialogue(device_handler) as debug:
a_coords, _ = buttons.passphrase("a", debug.layout_type)
actions = buttons.ButtonActions(debug.layout_type)
a_coords, _ = actions.passphrase("a")
for _ in range(10):
debug.click(a_coords)

22
tests/click_tests/test_pin.py
View File

@ -138,8 +138,9 @@ def prepare(
yield debug
if debug.layout_type is LayoutType.Delizia and tap:
btns = buttons.ScreenButtons(debug.layout_type)
go_next(debug)
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
else:
go_next(debug)
@ -154,12 +155,12 @@ def _input_pin(debug: "DebugLink", pin: str, check: bool = False) -> None:
"""Input the PIN"""
if check:
before = debug.read_layout().pin()
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
btns = buttons.ScreenButtons(debug.layout_type)
digits_order = debug.read_layout().tt_pin_digits_order()
for digit in pin:
digit_index = digits_order.index(digit)
coords = buttons.pin_passphrase_index(digit_index, debug.layout_type)
coords = btns.pin_passphrase_index(digit_index)
debug.click(coords)
elif debug.layout_type is LayoutType.Caesar:
for digit in pin:
@ -173,7 +174,8 @@ def _input_pin(debug: "DebugLink", pin: str, check: bool = False) -> None:
def _see_pin(debug: "DebugLink") -> None:
"""Navigate to "SHOW" and press it"""
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(buttons.input(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.pin_passphrase_input())
elif debug.layout_type is LayoutType.Caesar:
navigate_to_action_and_press(debug, SHOW, TR_PIN_ACTIONS)
@ -185,7 +187,8 @@ def _delete_pin(debug: "DebugLink", digits_to_delete: int, check: bool = True) -
for _ in range(digits_to_delete):
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(buttons.pin_passphrase_grid(9, debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.pin_passphrase_erase())
elif debug.layout_type is LayoutType.Caesar:
navigate_to_action_and_press(debug, DELETE, TR_PIN_ACTIONS)
@ -197,7 +200,11 @@ def _delete_pin(debug: "DebugLink", digits_to_delete: int, check: bool = True) -
def _delete_all(debug: "DebugLink", check: bool = True) -> None:
"""Navigate to "DELETE" and hold it until all digits are deleted"""
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(buttons.pin_passphrase_grid(9, debug.layout_type), hold_ms=1500)
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(
btns.pin_passphrase_erase(),
hold_ms=1500,
)
elif debug.layout_type is LayoutType.Caesar:
navigate_to_action_and_press(debug, DELETE, TR_PIN_ACTIONS, hold_ms=1000)
@ -221,7 +228,8 @@ def _cancel_pin(debug: "DebugLink") -> None:
def _confirm_pin(debug: "DebugLink") -> None:
"""Navigate to "ENTER" and press it"""
if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
debug.click(buttons.pin_passphrase_grid(11, debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.pin_confirm())
elif debug.layout_type is LayoutType.Caesar:
navigate_to_action_and_press(debug, ENTER, TR_PIN_ACTIONS)

45
tests/click_tests/test_tutorial_delizia.py
View File

@ -36,10 +36,11 @@ pytestmark = [
def test_tutorial_ignore_menu(device_handler: "BackgroundDeviceHandler"):
debug = device_handler.debuglink()
btns = buttons.ScreenButtons(debug.layout_type)
device_handler.run(device.show_device_tutorial)
assert debug.read_layout().title() == TR.tutorial__welcome_safe5
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_easy_navigation
@ -47,7 +48,7 @@ def test_tutorial_ignore_menu(device_handler: "BackgroundDeviceHandler"):
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_hold
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_well_done
debug.swipe_up()
@ -56,24 +57,25 @@ def test_tutorial_ignore_menu(device_handler: "BackgroundDeviceHandler"):
def test_tutorial_menu_open_close(device_handler: "BackgroundDeviceHandler"):
debug = device_handler.debuglink()
btns = buttons.ScreenButtons(debug.layout_type)
device_handler.run(device.show_device_tutorial)
assert debug.read_layout().title() == TR.tutorial__welcome_safe5
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_easy_navigation
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert TR.tutorial__did_you_know in debug.read_layout().text_content()
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_hold
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_well_done
debug.swipe_up()
@ -82,21 +84,22 @@ def test_tutorial_menu_open_close(device_handler: "BackgroundDeviceHandler"):
def test_tutorial_menu_exit(device_handler: "BackgroundDeviceHandler"):
debug = device_handler.debuglink()
btns = buttons.ScreenButtons(debug.layout_type)
device_handler.run(device.show_device_tutorial)
assert debug.read_layout().title() == TR.tutorial__welcome_safe5
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_easy_navigation
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert TR.tutorial__did_you_know in debug.read_layout().text_content()
debug.click(buttons.vertical_menu(debug.layout_type)[2])
debug.click(btns.vertical_menu_items()[2])
assert TR.instructions__hold_to_exit_tutorial in debug.read_layout().footer()
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_well_done
debug.swipe_up()
@ -105,19 +108,20 @@ def test_tutorial_menu_exit(device_handler: "BackgroundDeviceHandler"):
def test_tutorial_menu_repeat(device_handler: "BackgroundDeviceHandler"):
debug = device_handler.debuglink()
btns = buttons.ScreenButtons(debug.layout_type)
device_handler.run(device.show_device_tutorial)
assert debug.read_layout().title() == TR.tutorial__welcome_safe5
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_easy_navigation
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert TR.tutorial__did_you_know in debug.read_layout().text_content()
debug.click(buttons.vertical_menu(debug.layout_type)[1])
debug.click(btns.vertical_menu_items()[1])
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
@ -126,7 +130,7 @@ def test_tutorial_menu_repeat(device_handler: "BackgroundDeviceHandler"):
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_hold
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_well_done
debug.swipe_up()
@ -135,31 +139,32 @@ def test_tutorial_menu_repeat(device_handler: "BackgroundDeviceHandler"):
def test_tutorial_menu_funfact(device_handler: "BackgroundDeviceHandler"):
debug = device_handler.debuglink()
btns = buttons.ScreenButtons(debug.layout_type)
device_handler.run(device.show_device_tutorial)
assert debug.read_layout().title() == TR.tutorial__welcome_safe5
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_lets_begin
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_easy_navigation
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert TR.tutorial__did_you_know in debug.read_layout().text_content()
debug.click(buttons.vertical_menu(debug.layout_type)[0])
debug.click(btns.vertical_menu_items()[0])
assert debug.read_layout().text_content() in TR.tutorial__first_wallet.replace(
"\n", " "
)
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert TR.tutorial__did_you_know in debug.read_layout().text_content()
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.menu())
assert debug.read_layout().title() == TR.tutorial__title_handy_menu
debug.swipe_up()
assert debug.read_layout().title() == TR.tutorial__title_hold
debug.click(buttons.tap_to_confirm(debug.layout_type))
debug.click(btns.tap_to_confirm())
assert debug.read_layout().title() == TR.tutorial__title_well_done
debug.swipe_up()

9
tests/common.py
View File

@ -323,12 +323,13 @@ def click_info_button_bolt(debug: "DebugLink") -> Generator[Any, Any, ButtonRequ
def click_info_button_delizia(debug: "DebugLink"):
"""Click Shamir backup info button and return back."""
debug.click(buttons.corner_button(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.menu())
layout = debug.read_layout()
assert "VerticalMenu" in layout.all_components()
debug.click(buttons.vertical_menu(debug.layout_type)[0])
debug.click(buttons.corner_button(debug.layout_type))
debug.click(buttons.corner_button(debug.layout_type))
debug.click(btns.vertical_menu_items()[0])
debug.click(btns.menu())
debug.click(btns.menu())
def check_pin_backoff_time(attempts: int, start: float) -> None:

5
tests/device_tests/cardano/test_sign_tx.py
View File

@ -41,9 +41,10 @@ def show_details_input_flow(client: Client):
# Caesar - right button for "Show all"
client.debug.press_yes()
elif client.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(client.layout_type)
# Delizia - "Show all" button from context menu
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(buttons.vertical_menu(client.layout_type)[0])
client.debug.click(btns.menu())
client.debug.click(btns.vertical_menu_items()[0])
else:
raise NotImplementedError
# reset ui flow to continue "automatically"

7
tests/device_tests/test_msg_changepin_t2.py
View File

@ -187,17 +187,18 @@ def test_change_invalid_current(client: Client):
def test_pin_menu_cancel_setup(client: Client):
def cancel_pin_setup_input_flow():
yield
btns = buttons.ScreenButtons(client.layout_type)
# enter context menu
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(btns.menu())
client.debug.synchronize_at("VerticalMenu")
# click "Cancel PIN setup"
client.debug.click(buttons.vertical_menu(client.layout_type)[0])
client.debug.click(btns.vertical_menu_items()[0])
client.debug.synchronize_at("Paragraphs")
# swipe through info screen
client.debug.swipe_up()
client.debug.synchronize_at("PromptScreen")
# tap to confirm
client.debug.click(buttons.tap_to_confirm(client.layout_type))
client.debug.click(btns.tap_to_confirm())
with client, pytest.raises(Cancelled):
client.set_input_flow(cancel_pin_setup_input_flow)

154
tests/input_flows.py
View File

@ -316,12 +316,13 @@ class InputFlowSignVerifyMessageLong(InputFlowBase):
layouts: list[LayoutContent] = []
br = yield # confirm address
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.read_layout()
self.debug.press_yes()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
br = yield
self.debug.read_layout()
@ -351,8 +352,9 @@ class InputFlowSignMessageInfo(InputFlowBase):
def input_flow_bolt(self) -> BRGeneratorType:
yield
# signing address/message info
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
self.debug.click(btns.menu())
# signing address "x"
self.debug.press_no()
self.debug.synchronize_at("IconDialog")
@ -363,10 +365,11 @@ class InputFlowSignMessageInfo(InputFlowBase):
def input_flow_delizia(self) -> BRGeneratorType:
yield
# show address/message info
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
self.debug.click(btns.vertical_menu_items()[0])
self.debug.click(btns.menu())
self.debug.click(btns.vertical_menu_items()[1])
# address mismatch? yes!
self.debug.swipe_up()
yield
@ -378,14 +381,15 @@ class InputFlowShowAddressQRCode(InputFlowBase):
def input_flow_bolt(self) -> BRGeneratorType:
yield
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
# synchronize; TODO get rid of this once we have single-global-layout
self.debug.synchronize_at("SimplePage")
self.debug.swipe_left()
self.debug.swipe_right()
self.debug.swipe_left()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.press_no()
self.debug.press_no()
self.debug.press_yes()
@ -413,26 +417,27 @@ class InputFlowShowAddressQRCode(InputFlowBase):
def input_flow_delizia(self) -> BRGeneratorType:
yield
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
# synchronize; TODO get rid of this once we have single-global-layout
self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
self.debug.synchronize_at("Qr")
# qr code
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
# address details
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[2])
self.debug.click(btns.vertical_menu_items()[2])
# cancel
self.debug.swipe_up()
# really cancel
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
layout = self.debug.read_layout()
while "PromptScreen" not in layout.all_components():
@ -440,7 +445,7 @@ class InputFlowShowAddressQRCode(InputFlowBase):
layout = self.debug.read_layout()
self.debug.synchronize_at("PromptScreen")
# tap to confirm
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
class InputFlowShowAddressQRCodeCancel(InputFlowBase):
@ -449,12 +454,13 @@ class InputFlowShowAddressQRCodeCancel(InputFlowBase):
def input_flow_bolt(self) -> BRGeneratorType:
yield
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
# synchronize; TODO get rid of this once we have single-global-layout
self.debug.synchronize_at("SimplePage")
self.debug.swipe_left()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.press_no()
self.debug.press_yes()
@ -475,25 +481,26 @@ class InputFlowShowAddressQRCodeCancel(InputFlowBase):
def input_flow_delizia(self) -> BRGeneratorType:
yield
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
# synchronize; TODO get rid of this once we have single-global-layout
self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
self.debug.synchronize_at("Qr")
# qr code
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
# address details
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[2])
self.debug.click(btns.vertical_menu_items()[2])
# cancel
self.debug.swipe_up()
self.debug.synchronize_at("PromptScreen")
# really cancel
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
class InputFlowShowMultisigXPUBs(InputFlowBase):
@ -513,6 +520,7 @@ class InputFlowShowMultisigXPUBs(InputFlowBase):
def input_flow_bolt(self) -> BRGeneratorType:
yield # multisig address warning
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.press_yes()
yield # show address
@ -521,7 +529,7 @@ class InputFlowShowMultisigXPUBs(InputFlowBase):
assert "(MULTISIG)" in layout.title()
assert layout.text_content().replace(" ", "") == self.address
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
assert "Qr" in self.all_components()
self.debug.swipe_left()
@ -538,7 +546,7 @@ class InputFlowShowMultisigXPUBs(InputFlowBase):
content = layout.text_content().replace(" ", "")
assert self.xpubs[xpub_num] in content
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# show address
self.debug.press_no()
# address mismatch
@ -590,26 +598,27 @@ class InputFlowShowMultisigXPUBs(InputFlowBase):
def input_flow_delizia(self) -> BRGeneratorType:
yield # multisig address warning
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
yield # show address
layout = self.debug.read_layout()
assert TR.address__title_receive_address in layout.title()
assert layout.text_content().replace(" ", "") == self.address
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
assert "VerticalMenu" in self.all_components()
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
self.debug.synchronize_at("Qr")
# qr code
assert "Qr" in self.all_components()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
assert "VerticalMenu" in self.all_components()
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
layout = self.debug.synchronize_at("AddressDetails")
# address details
assert "Multisig 2 of 3" in layout.screen_content()
@ -620,17 +629,17 @@ class InputFlowShowMultisigXPUBs(InputFlowBase):
self.debug.swipe_left()
self.debug.swipe_left()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[2])
self.debug.click(btns.vertical_menu_items()[2])
# cancel
self.debug.swipe_up()
# really cancel
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
layout = self.debug.synchronize_at("Paragraphs")
# address
while "PromptScreen" not in layout.all_components():
@ -647,6 +656,7 @@ class InputFlowShowXpubQRCode(InputFlowBase):
self.passphrase = passphrase
def input_flow_bolt(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
if self.passphrase:
yield
self.debug.press_yes()
@ -659,14 +669,14 @@ class InputFlowShowXpubQRCode(InputFlowBase):
self.debug.press_yes()
br = yield
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# synchronize; TODO get rid of this once we have single-global-layout
self.debug.synchronize_at("SimplePage")
self.debug.swipe_left()
self.debug.swipe_right()
self.debug.swipe_left()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.press_no()
self.debug.press_no()
for _ in range(br.pages - 1):
@ -701,6 +711,7 @@ class InputFlowShowXpubQRCode(InputFlowBase):
self.debug.press_middle()
def input_flow_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
if self.passphrase:
yield
self.debug.press_yes()
@ -716,32 +727,32 @@ class InputFlowShowXpubQRCode(InputFlowBase):
assert layout.title() in (TR.address__public_key, "XPUB")
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
assert "VerticalMenu" in self.all_components()
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
self.debug.synchronize_at("Qr")
# qr code
assert "Qr" in self.all_components()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
# menu
assert "VerticalMenu" in self.all_components()
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
layout = self.debug.synchronize_at("AddressDetails")
# address details
assert TR.address_details__derivation_path in layout.screen_content()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
layout = self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.vertical_menu(self.client.layout_type)[2])
self.debug.click(btns.vertical_menu_items()[2])
# cancel
self.debug.swipe_up()
# really cancel
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
layout = self.debug.synchronize_at("VerticalMenu")
# menu
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
layout = self.debug.synchronize_at("Paragraphs")
# address
while "PromptScreen" not in layout.all_components():
@ -854,6 +865,7 @@ class InputFlowSignTxHighFee(InputFlowBase):
def sign_tx_go_to_info(client: Client) -> Generator[None, messages.ButtonRequest, str]:
btns = buttons.ScreenButtons(client.layout_type)
yield # confirm output
client.debug.read_layout()
client.debug.press_yes()
@ -868,7 +880,7 @@ def sign_tx_go_to_info(client: Client) -> Generator[None, messages.ButtonRequest
layout = client.debug.read_layout()
content = layout.text_content()
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(btns.menu())
return content
@ -876,6 +888,7 @@ def sign_tx_go_to_info(client: Client) -> Generator[None, messages.ButtonRequest
def sign_tx_go_to_info_t3t1(
client: Client, multi_account: bool = False
) -> Generator[None, messages.ButtonRequest, str]:
btns = buttons.ScreenButtons(client.layout_type)
yield # confirm output
client.debug.read_layout()
client.debug.swipe_up()
@ -890,22 +903,22 @@ def sign_tx_go_to_info_t3t1(
yield # confirm transaction
client.debug.read_layout()
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(btns.menu())
client.debug.synchronize_at("VerticalMenu")
client.debug.click(buttons.vertical_menu(client.layout_type)[0])
client.debug.click(btns.vertical_menu_items()[0])
layout = client.debug.read_layout()
content = layout.text_content()
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(btns.menu())
client.debug.synchronize_at("VerticalMenu")
client.debug.click(buttons.vertical_menu(client.layout_type)[1])
client.debug.click(btns.vertical_menu_items()[1])
layout = client.debug.read_layout()
content += " " + layout.text_content()
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(buttons.corner_button(client.layout_type))
client.debug.click(btns.menu())
client.debug.click(btns.menu())
return content
@ -1018,11 +1031,12 @@ class InputFlowSignTxInformationCancel(InputFlowBase):
self.debug.press_left()
def input_flow_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
yield from sign_tx_go_to_info_t3t1(self.client)
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.vertical_menu(self.client.layout_type)[2])
self.debug.click(btns.menu())
self.debug.click(btns.vertical_menu_items()[2])
self.debug.synchronize_at("PromptScreen")
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
class InputFlowSignTxInformationReplacement(InputFlowBase):
@ -1030,6 +1044,7 @@ class InputFlowSignTxInformationReplacement(InputFlowBase):
super().__init__(client)
def input_flow_bolt(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
yield # confirm txid
self.debug.press_yes()
yield # confirm address
@ -1043,8 +1058,8 @@ class InputFlowSignTxInformationReplacement(InputFlowBase):
self.debug.press_yes()
yield # transaction summary, press info
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.click(btns.menu())
self.debug.press_yes()
def input_flow_caesar(self) -> BRGeneratorType:
@ -2326,17 +2341,18 @@ class InputFlowResetSkipBackup(InputFlowBase):
self.debug.press_no()
def input_flow_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
yield from self.BAK.confirm_new_wallet()
yield # Skip Backup
assert TR.backup__new_wallet_created in self.text_content()
self.debug.swipe_up()
yield
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
self.debug.swipe_up()
self.debug.synchronize_at("PromptScreen")
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
class InputFlowConfirmAllWarnings(InputFlowBase):
@ -2355,6 +2371,7 @@ class InputFlowConfirmAllWarnings(InputFlowBase):
return self.input_flow_bolt()
def input_flow_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
br = yield
while True:
# wait for homescreen to go away
@ -2372,9 +2389,9 @@ class InputFlowConfirmAllWarnings(InputFlowBase):
TR.send__cancel_sign,
)
if any(needle.lower() in text for needle in hi_prio):
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[1])
self.debug.click(btns.vertical_menu_items()[1])
elif "PromptScreen" in layout.all_components():
self.debug.press_yes()
elif "SwipeContent" in layout.all_components():
@ -2398,7 +2415,8 @@ class InputFlowFidoConfirm(InputFlowBase):
yield from self.input_flow_bolt()
def input_flow_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
while True:
yield
self.debug.swipe_up()
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())

54
tests/input_flows_helpers.py
View File

@ -143,13 +143,14 @@ class RecoveryFlow:
else:
self.debug.press_no()
elif self.client.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(self.client.layout_type)
assert TR.recovery__enter_each_word in self._text_content()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
if confirm:
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
else:
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
else:
assert TR.recovery__enter_any_share in self._text_content()
self.debug.press_no()
@ -175,14 +176,15 @@ class RecoveryFlow:
assert TR.regexp("recovery__x_of_y_entered_template").search(
self._text_content()
)
self.debug.click(buttons.corner_button(self.client.layout_type))
btns = buttons.ScreenButtons(self.client.layout_type)
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
assert (yield).name == "abort_recovery"
self.debug.swipe_up()
layout = self.debug.read_layout()
assert layout.title() == TR.recovery__title_cancel_recovery
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
else:
assert TR.regexp("recovery__x_of_y_entered_template").search(
self._text_content()
@ -337,16 +339,17 @@ class RecoveryFlow:
self.debug.press_yes()
def click_info_delizia(self) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
# Moving through the menu into the show_shares screen
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
br = yield
assert br.name == "show_shares"
assert br.code == B.Other
# Getting back to the homepage
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.click(btns.menu())
class EthereumFlow:
@ -461,6 +464,7 @@ class EthereumFlow:
def _confirm_tx_delizia(
self, cancel: bool, info: bool, go_back_from_summary: bool
) -> BRGeneratorType:
btns = buttons.ScreenButtons(self.client.layout_type)
assert (yield).name == "confirm_output"
title = self.debug.read_layout().title()
assert TR.words__address in title
@ -481,17 +485,17 @@ class EthereumFlow:
self.debug.press_yes()
assert (yield).name == "confirm_ethereum_tx"
if info:
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
text = self.debug.read_layout().text_content()
assert TR.ethereum__gas_limit in text
assert TR.ethereum__gas_price in text
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.click(btns.menu())
self.debug.swipe_up()
self.debug.read_layout()
self.debug.click(buttons.tap_to_confirm(self.client.layout_type))
self.debug.click(btns.tap_to_confirm())
assert (yield).name == "confirm_ethereum_tx"
def confirm_tx(
@ -527,10 +531,11 @@ class EthereumFlow:
TR.ethereum__staking_claim_intro,
)
if self.client.layout_type is LayoutType.Bolt:
btns = buttons.ScreenButtons(self.client.layout_type)
# confirm intro
if info:
self.debug.click(
buttons.corner_button(self.client.layout_type),
btns.menu(),
)
assert self.debug.read_layout().title() in (
TR.ethereum__staking_stake_address,
@ -552,17 +557,18 @@ class EthereumFlow:
self.debug.press_yes()
elif self.client.layout_type is LayoutType.Delizia:
btns = buttons.ScreenButtons(self.client.layout_type)
# confirm intro
if info:
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
assert self.debug.read_layout().title() in (
TR.ethereum__staking_stake_address,
TR.ethereum__staking_claim_address,
)
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.click(btns.menu())
self.debug.swipe_up()
br = yield
@ -571,13 +577,13 @@ class EthereumFlow:
# confirm summary
if info:
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.synchronize_at("VerticalMenu")
self.debug.click(buttons.vertical_menu(self.client.layout_type)[0])
self.debug.click(btns.vertical_menu_items()[0])
assert TR.ethereum__gas_limit in self.debug.read_layout().text_content()
assert TR.ethereum__gas_price in self.debug.read_layout().text_content()
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(buttons.corner_button(self.client.layout_type))
self.debug.click(btns.menu())
self.debug.click(btns.menu())
self.debug.swipe_up()
# br = yield # FIXME: no BR on sign transaction

25
tests/upgrade_tests/recovery_old.py
View File

@ -10,48 +10,45 @@ def _enter_word(
debug: "DebugLink", word: str, is_slip39: bool = False
) -> "LayoutContent":
typed_word = word[:4]
for coords in buttons.type_word(typed_word, debug.layout_type, is_slip39=is_slip39):
actions = buttons.ButtonActions(debug.layout_type)
btns = buttons.ScreenButtons(debug.layout_type)
for coords in actions.type_word(typed_word, is_slip39=is_slip39):
debug.click(coords)
debug.read_layout(wait=False)
debug.click(buttons.input(debug.layout_type))
debug.click(btns.mnemonic_confirm())
return debug.read_layout(wait=True)
def confirm_recovery(debug: "DebugLink") -> None:
debug.click(buttons.ok(debug.layout_type))
btns = buttons.ScreenButtons(debug.layout_type)
debug.click(btns.ok())
debug.read_layout(wait=True)
def select_number_of_words(
debug: "DebugLink", tag_version: tuple | None, num_of_words: int = 20
) -> None:
btns = buttons.ScreenButtons(debug.layout_type)
if "SelectWordCount" not in debug.read_layout().all_components():
debug.click(buttons.ok(debug.layout_type))
debug.click(btns.ok())
debug.read_layout(wait=True)
if tag_version is None or tag_version > (2, 8, 8):
# layout changed after adding the cancel button
coords_map = {
12: buttons.grid34(0, 2, debug.layout_type),
18: buttons.grid34(1, 2, debug.layout_type),
20: buttons.grid34(2, 2, debug.layout_type),
24: buttons.grid34(1, 3, debug.layout_type),
33: buttons.grid34(2, 3, debug.layout_type),
}
coords = coords_map.get(num_of_words)
coords = btns.word_count_all_word(num_of_words)
else:
word_option_offset = 6
word_options = (12, 18, 20, 24, 33)
index = word_option_offset + word_options.index(
num_of_words
) # raises if num of words is invalid
coords = buttons.grid34(index % 3, index // 3, debug.layout_type)
coords = btns.grid34(index % 3, index // 3)
debug.click(coords)
debug.read_layout(wait=True)
def enter_share(debug: "DebugLink", share: str) -> "LayoutContent":
debug.click(buttons.ok(debug.layout_type))
debug.click(buttons.ScreenButtons(debug.layout_type).ok())
for word in share.split(" "):
_enter_word(debug, word, is_slip39=True)