All checks were successful
Zapret source guards / validate (push) Successful in 11s
The page 'Сменить режим DPI' offered three modes on Linux, but only Zapret 2 (nfqws2) has an engine there. Windows keeps all three. Elsewhere a saved Zapret 1 / Orchestra choice (e.g. a settings file copied from Windows) is read as Zapret 2, the DPI page shows one option without the winws2.exe name, and the two tour steps about the modes are skipped. Owner decision of 2026-11-21. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
1467 lines
61 KiB
Python
1467 lines
61 KiB
Python
from __future__ import annotations
|
||
|
||
import os
|
||
import sys
|
||
import unittest
|
||
from pathlib import Path
|
||
from tempfile import TemporaryDirectory
|
||
from types import SimpleNamespace
|
||
from unittest.mock import Mock, patch
|
||
|
||
|
||
PROJECT_SRC = Path(__file__).resolve().parents[1] / "src"
|
||
if str(PROJECT_SRC) not in sys.path:
|
||
sys.path.insert(0, str(PROJECT_SRC))
|
||
|
||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||
|
||
from PyQt6.QtCore import QPoint, QRect # noqa: E402
|
||
from PyQt6.QtWidgets import QApplication, QPushButton, QScrollArea, QVBoxLayout, QWidget # noqa: E402
|
||
|
||
|
||
def _app() -> QApplication:
|
||
return QApplication.instance() or QApplication([])
|
||
|
||
|
||
class OnboardingFlagSettingsTests(unittest.TestCase):
|
||
def test_flag_defaults_to_not_shown_and_survives_normalize(self) -> None:
|
||
from settings.normalize import normalize_settings
|
||
from settings.schema import build_default_settings
|
||
|
||
defaults = build_default_settings()
|
||
self.assertIs(defaults["warnings"]["onboarding_tour_done"], False)
|
||
|
||
normalized = normalize_settings({"warnings": {"onboarding_tour_done": True}})
|
||
self.assertIs(normalized["warnings"]["onboarding_tour_done"], True)
|
||
|
||
def test_flag_round_trips_through_sqlite_store(self) -> None:
|
||
from settings import store as settings_store
|
||
|
||
with TemporaryDirectory() as temp_dir:
|
||
with patch("settings.store.MAIN_DIRECTORY", str(temp_dir)):
|
||
try:
|
||
settings_store.prepare_settings_database()
|
||
self.assertFalse(settings_store.get_onboarding_tour_done())
|
||
settings_store.set_onboarding_tour_done(True)
|
||
self.assertTrue(settings_store.get_onboarding_tour_done())
|
||
self.assertTrue(settings_store.read_settings()["warnings"]["onboarding_tour_done"])
|
||
finally:
|
||
settings_store.close_settings_database()
|
||
|
||
|
||
class OnboardingPostStartupTests(unittest.TestCase):
|
||
def _install(self, *, done: bool, start_results: list[bool]):
|
||
from main import post_startup_onboarding
|
||
|
||
_app()
|
||
startup_host = SimpleNamespace(
|
||
startup_post_init_ready=object(),
|
||
startup_state=SimpleNamespace(post_init_ready=True),
|
||
is_alive=Mock(return_value=True),
|
||
start_onboarding_tour=Mock(side_effect=list(start_results)),
|
||
)
|
||
mark_done = Mock()
|
||
delays: list[int] = []
|
||
|
||
def _schedule(delay_ms, callback):
|
||
delays.append(int(delay_ms))
|
||
if len(delays) <= len(start_results):
|
||
callback()
|
||
|
||
with (
|
||
patch.object(post_startup_onboarding, "bind_startup_gate", side_effect=lambda _s, cb, **_k: cb()),
|
||
patch.object(post_startup_onboarding, "schedule_after", side_effect=_schedule),
|
||
patch.object(post_startup_onboarding, "enqueue_subsystem_task", side_effect=lambda _q, _n, target: target()),
|
||
patch.object(post_startup_onboarding, "_read_tour_done", return_value=done),
|
||
patch.object(post_startup_onboarding, "_mark_tour_done", mark_done),
|
||
patch.object(post_startup_onboarding, "log"),
|
||
):
|
||
post_startup_onboarding.install_onboarding_tour(startup_host)
|
||
return startup_host, mark_done, delays
|
||
|
||
def test_tour_is_not_shown_again_when_flag_is_set(self) -> None:
|
||
startup_host, mark_done, delays = self._install(done=True, start_results=[True])
|
||
|
||
startup_host.start_onboarding_tour.assert_not_called()
|
||
mark_done.assert_not_called()
|
||
self.assertEqual(delays, [])
|
||
|
||
def test_first_start_shows_tour_and_remembers_it(self) -> None:
|
||
startup_host, mark_done, _delays = self._install(done=False, start_results=[True])
|
||
|
||
startup_host.start_onboarding_tour.assert_called_once_with()
|
||
mark_done.assert_called_once_with()
|
||
|
||
def test_waits_while_window_is_not_ready_and_marks_only_after_show(self) -> None:
|
||
startup_host, mark_done, delays = self._install(done=False, start_results=[False, False, True])
|
||
|
||
self.assertEqual(startup_host.start_onboarding_tour.call_count, 3)
|
||
mark_done.assert_called_once_with()
|
||
self.assertEqual(len(delays), 3)
|
||
|
||
|
||
class _FakePage(QWidget):
|
||
def __init__(self, parent=None) -> None:
|
||
super().__init__(parent)
|
||
layout = QVBoxLayout(self)
|
||
self.start_btn = QPushButton("Запустить", self)
|
||
layout.addWidget(self.start_btn)
|
||
|
||
def onboarding_target(self, name):
|
||
return self.start_btn if name == "start" else None
|
||
|
||
|
||
def _build_window():
|
||
window = QWidget()
|
||
window.resize(900, 640)
|
||
layout = QVBoxLayout(window)
|
||
page = _FakePage(window)
|
||
layout.addWidget(page)
|
||
|
||
class Host:
|
||
def show_page(self, _name, allow_internal=False):
|
||
return True
|
||
|
||
def get_loaded_page(self, _name):
|
||
return page
|
||
|
||
def current_page(self):
|
||
return page
|
||
|
||
window.ui_session = SimpleNamespace(
|
||
nav_items={},
|
||
nav_header_by_group={},
|
||
nav_headers=[],
|
||
page_host=Host(),
|
||
)
|
||
return window, page
|
||
|
||
|
||
class OnboardingOverlayTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _overlay(self, steps):
|
||
from app.page_names import PageName
|
||
from ui.onboarding.overlay import OnboardingOverlay
|
||
from ui.onboarding.steps import TourContext
|
||
|
||
window, page = _build_window()
|
||
window.show()
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
overlay = OnboardingOverlay(window, context, steps)
|
||
return window, overlay
|
||
|
||
def test_steps_without_targets_are_skipped(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
TourStep("missing", _page_target("nothing"), page="control"),
|
||
TourStep("user_presets", _page_target("presets_list"), page="user_presets"),
|
||
TourStep("finish", _page_target("tour_card"), page="control", target_optional=True),
|
||
)
|
||
window, overlay = self._overlay(steps)
|
||
try:
|
||
self.assertTrue(overlay.start())
|
||
# Страницы user_presets в этом режиме нет — шаг убран сразу.
|
||
self.assertEqual(overlay.step_keys(), ["welcome", "start", "missing", "finish"])
|
||
self.assertEqual(overlay.current_step_key(), "welcome")
|
||
overlay.go_next()
|
||
self.assertEqual(overlay.current_step_key(), "start")
|
||
overlay.go_next()
|
||
# Цели «missing» на странице нет — шаг пропущен.
|
||
self.assertEqual(overlay.current_step_key(), "finish")
|
||
overlay.go_back()
|
||
self.assertEqual(overlay.current_step_key(), "start")
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_wiki_button_opens_step_article_and_hides_without_one(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
url = "https://otukcszfwr.zapret.moe/Zapret2/preset"
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("start", _page_target("start"), page="control", wiki_url=url),
|
||
)
|
||
window, overlay = self._overlay(steps)
|
||
try:
|
||
overlay.start()
|
||
button = overlay._card.wiki_button
|
||
self.assertTrue(button.isHidden())
|
||
overlay.go_next()
|
||
self.assertFalse(button.isHidden())
|
||
self.assertEqual(button.getUrl().toString(), url)
|
||
self.assertEqual(button.text(), "Подробнее в вики")
|
||
overlay.go_back()
|
||
self.assertTrue(button.isHidden())
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_overlay_is_child_of_window_not_separate_window(self) -> None:
|
||
from ui.onboarding.steps import TourStep
|
||
|
||
window, overlay = self._overlay((TourStep("welcome", hero=True),))
|
||
try:
|
||
overlay.start()
|
||
self.assertFalse(overlay.isWindow())
|
||
self.assertIs(overlay.parentWidget(), window)
|
||
self.assertFalse(any(child.isWindow() for child in overlay.findChildren(QWidget)))
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_skip_finishes_tour(self) -> None:
|
||
from ui.onboarding.steps import TourStep
|
||
|
||
window, overlay = self._overlay((TourStep("welcome", hero=True), TourStep("how", hero=True)))
|
||
finished = Mock()
|
||
overlay.finished.connect(finished)
|
||
try:
|
||
overlay.start()
|
||
overlay.finish("skipped", immediate=True)
|
||
finished.assert_called_once_with("skipped")
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class OnboardingKeyboardTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _running_overlay(self):
|
||
from PyQt6.QtTest import QTest
|
||
|
||
from app.page_names import PageName
|
||
from ui.onboarding.overlay import OnboardingOverlay
|
||
from ui.onboarding.steps import TourContext, TourStep, _page_target
|
||
|
||
window, page = _build_window()
|
||
window.show()
|
||
window.activateWindow()
|
||
QTest.qWaitForWindowActive(window, 1000)
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
TourStep("finish", hero=True),
|
||
)
|
||
overlay = OnboardingOverlay(window, context, steps)
|
||
overlay.start()
|
||
QApplication.processEvents()
|
||
return window, page, overlay
|
||
|
||
def test_arrow_keys_page_through_steps_while_card_button_has_focus(self) -> None:
|
||
from PyQt6.QtCore import Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
window, _page, overlay = self._running_overlay()
|
||
try:
|
||
focus = QApplication.focusWidget()
|
||
self.assertTrue(focus is not None and overlay.isAncestorOf(focus))
|
||
QTest.keyClick(focus, Qt.Key.Key_Right)
|
||
self.assertEqual(overlay.current_step_key(), "start")
|
||
QTest.keyClick(QApplication.focusWidget(), Qt.Key.Key_Left)
|
||
self.assertEqual(overlay.current_step_key(), "welcome")
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_tab_does_not_leave_the_tour_card(self) -> None:
|
||
from PyQt6.QtCore import Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
window, page, overlay = self._running_overlay()
|
||
try:
|
||
overlay.go_next()
|
||
for _ in range(6):
|
||
QTest.keyClick(QApplication.focusWidget(), Qt.Key.Key_Tab)
|
||
focus = QApplication.focusWidget()
|
||
self.assertTrue(focus is not None and overlay.isAncestorOf(focus))
|
||
self.assertFalse(page.isAncestorOf(focus))
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_backdrop_grab_does_not_break_a_click_in_progress(self) -> None:
|
||
from PyQt6.QtCore import Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
window, _page, overlay = self._running_overlay()
|
||
try:
|
||
button = overlay._card.next_button
|
||
QTest.mousePress(button, Qt.MouseButton.LeftButton)
|
||
overlay._refresh_blur()
|
||
QTest.mouseRelease(button, Qt.MouseButton.LeftButton)
|
||
self.assertEqual(overlay.current_step_key(), "start")
|
||
self.assertTrue(overlay.isVisible())
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class _ParentPage(QWidget):
|
||
"""Страница-родитель: открывает вложенную страницу и показывает «меню»."""
|
||
|
||
def __init__(self, host, parent=None) -> None:
|
||
super().__init__(parent)
|
||
self._host = host
|
||
layout = QVBoxLayout(self)
|
||
self.row = QPushButton("Строка", self)
|
||
self.second = QPushButton("Вторая", self)
|
||
self.menu = QPushButton("Меню", self)
|
||
layout.addWidget(self.row)
|
||
layout.addWidget(self.second)
|
||
layout.addWidget(self.menu)
|
||
self.menu.hide()
|
||
self.allow_subpage = True
|
||
self.open_calls: list[str] = []
|
||
self.states: list[str | None] = []
|
||
|
||
def onboarding_target(self, name):
|
||
if name == "menu":
|
||
return [self.row, self.menu] if self.menu.isVisible() else None
|
||
if name == "pair":
|
||
return [self.row, None, self.second]
|
||
return None
|
||
|
||
def onboarding_set_state(self, state) -> None:
|
||
self.states.append(state)
|
||
self.menu.setVisible(state == "menu")
|
||
|
||
def onboarding_open_subpage(self, key) -> bool:
|
||
self.open_calls.append(key)
|
||
if not self.allow_subpage:
|
||
return False
|
||
return self._host.show_page(self._host.child_name)
|
||
|
||
|
||
class _ChildPage(QWidget):
|
||
def __init__(self, parent=None) -> None:
|
||
super().__init__(parent)
|
||
layout = QVBoxLayout(self)
|
||
self.editor = QPushButton("Текст пресета", self)
|
||
layout.addWidget(self.editor)
|
||
|
||
def onboarding_target(self, name):
|
||
return self.editor if name == "editor" else None
|
||
|
||
|
||
def _build_multi_page_window():
|
||
from app.page_names import PageName
|
||
|
||
window = QWidget()
|
||
window.resize(900, 640)
|
||
layout = QVBoxLayout(window)
|
||
|
||
class Host:
|
||
child_name = PageName.ZAPRET2_PRESET_RAW_EDITOR
|
||
|
||
def __init__(self) -> None:
|
||
self.pages = {}
|
||
self.current = None
|
||
self.shown: list = []
|
||
|
||
def show_page(self, name, allow_internal=False):
|
||
_ = allow_internal
|
||
self.shown.append(name)
|
||
for page_name, page in self.pages.items():
|
||
page.setVisible(page_name == name)
|
||
self.current = self.pages.get(name)
|
||
return self.current is not None
|
||
|
||
def get_loaded_page(self, name):
|
||
return self.pages.get(name)
|
||
|
||
def current_page(self):
|
||
return self.current
|
||
|
||
host = Host()
|
||
control = _FakePage(window)
|
||
parent = _ParentPage(host, window)
|
||
child = _ChildPage(window)
|
||
host.pages = {
|
||
PageName.ZAPRET2_MODE_CONTROL: control,
|
||
PageName.ZAPRET2_USER_PRESETS: parent,
|
||
PageName.ZAPRET2_PRESET_RAW_EDITOR: child,
|
||
}
|
||
for page in host.pages.values():
|
||
layout.addWidget(page)
|
||
host.show_page(PageName.ZAPRET2_MODE_CONTROL)
|
||
window.ui_session = SimpleNamespace(
|
||
nav_items={},
|
||
nav_header_by_group={},
|
||
nav_headers=[],
|
||
page_host=host,
|
||
)
|
||
return window, host, control, parent, child
|
||
|
||
|
||
class OnboardingSubpageAndStateTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _overlay(self, steps):
|
||
from app.page_names import PageName
|
||
from ui.onboarding.overlay import OnboardingOverlay
|
||
from ui.onboarding.steps import TourContext
|
||
|
||
window, host, control, parent, child = _build_multi_page_window()
|
||
window.show()
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={
|
||
"control": PageName.ZAPRET2_MODE_CONTROL,
|
||
"user_presets": PageName.ZAPRET2_USER_PRESETS,
|
||
"preset_editor": PageName.ZAPRET2_PRESET_RAW_EDITOR,
|
||
},
|
||
current_page=control,
|
||
)
|
||
overlay = OnboardingOverlay(window, context, steps)
|
||
return window, host, parent, child, overlay
|
||
|
||
def test_subpage_is_opened_by_its_parent_page_and_not_reopened(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("file", _page_target("editor"), page="preset_editor"),
|
||
TourStep("file_again", _page_target("editor"), page="preset_editor"),
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
)
|
||
window, host, parent, child, overlay = self._overlay(steps)
|
||
try:
|
||
overlay.start()
|
||
overlay.go_next()
|
||
self.assertEqual(overlay.current_step_key(), "file")
|
||
self.assertEqual(parent.open_calls, ["preset_editor"])
|
||
self.assertIs(host.current, child)
|
||
overlay.go_next()
|
||
# Страница уже открыта — родителя второй раз не дёргаем.
|
||
self.assertEqual(overlay.current_step_key(), "file_again")
|
||
self.assertEqual(parent.open_calls, ["preset_editor"])
|
||
overlay.go_next()
|
||
overlay.go_back()
|
||
# После ухода на другую страницу «Назад» снова открывает через родителя.
|
||
self.assertEqual(overlay.current_step_key(), "file_again")
|
||
self.assertEqual(parent.open_calls, ["preset_editor", "preset_editor"])
|
||
self.assertIs(host.current, child)
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_subpage_step_is_skipped_when_parent_cannot_open_it(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("file", _page_target("editor"), page="preset_editor", target_optional=True),
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
)
|
||
window, _host, parent, _child, overlay = self._overlay(steps)
|
||
parent.allow_subpage = False
|
||
try:
|
||
overlay.start()
|
||
overlay.go_next()
|
||
self.assertEqual(parent.open_calls, ["preset_editor"])
|
||
self.assertEqual(overlay.current_step_key(), "start")
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_page_state_is_shown_on_its_step_and_reset_when_leaving(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("menu", _page_target("menu"), page="user_presets", page_state="menu"),
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
)
|
||
window, _host, parent, _child, overlay = self._overlay(steps)
|
||
try:
|
||
overlay.start()
|
||
overlay.go_next()
|
||
self.assertEqual(overlay.current_step_key(), "menu")
|
||
self.assertEqual(parent.states, ["menu"])
|
||
self.assertEqual(overlay._targets, [parent.row, parent.menu])
|
||
overlay.go_next()
|
||
self.assertEqual(parent.states, ["menu", None])
|
||
overlay.go_back()
|
||
self.assertEqual(parent.states, ["menu", None, "menu"])
|
||
overlay.finish("skipped", immediate=True)
|
||
self.assertEqual(parent.states, ["menu", None, "menu", None])
|
||
self.assertFalse(parent.menu.isVisible())
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_list_target_highlights_every_shown_widget(self) -> None:
|
||
from ui.onboarding.steps import TourContext, _page_target
|
||
|
||
window, _host, parent, _child, _overlay = self._overlay(())
|
||
try:
|
||
parent.show()
|
||
context = TourContext(window=window, current_page=parent)
|
||
self.assertEqual(_page_target("pair")(context), [parent.row, parent.second])
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class MenuPreviewTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def test_real_menu_is_shown_as_picture_inside_page_not_as_window(self) -> None:
|
||
from PyQt6.QtCore import QRect
|
||
from qfluentwidgets import Action, RoundMenu
|
||
|
||
from ui.onboarding.menu_preview import create_menu_preview, place_menu_preview, remove_menu_preview
|
||
|
||
host = QWidget()
|
||
host.resize(600, 400)
|
||
row = QPushButton("Строка", host)
|
||
row.setGeometry(10, 10, 580, 40)
|
||
host.show()
|
||
try:
|
||
menu = RoundMenu(parent=host)
|
||
menu.addAction(Action("Открыть", menu))
|
||
menu.addAction(Action("Дублировать", menu))
|
||
preview = create_menu_preview(host, menu)
|
||
self.assertIsNotNone(preview)
|
||
self.assertFalse(preview.isWindow())
|
||
self.assertFalse(menu.isVisible())
|
||
place_menu_preview(preview, row, QRect(0, 0, row.width(), row.height()))
|
||
self.assertTrue(preview.isVisible())
|
||
self.assertTrue(host.rect().contains(preview.geometry()))
|
||
self.assertFalse(any(w.isWindow() and w.isVisible() for w in QApplication.topLevelWidgets() if w is not host))
|
||
remove_menu_preview(preview)
|
||
self.assertFalse(preview.isVisible())
|
||
finally:
|
||
host.close()
|
||
host.deleteLater()
|
||
|
||
|
||
class TourStepCapabilityTests(unittest.TestCase):
|
||
"""Steps about things a system does not have are left out of its tour; the other variant is used instead."""
|
||
|
||
@staticmethod
|
||
def _system(*capabilities):
|
||
from types import SimpleNamespace
|
||
|
||
return SimpleNamespace(has=lambda name: name in capabilities)
|
||
|
||
def test_windows_tour_keeps_the_windows_steps_and_the_full_quick_actions_text(self) -> None:
|
||
from platforms import Cap
|
||
from ui.onboarding.steps import tour_steps_for
|
||
|
||
keys = [step.key for step in tour_steps_for(self._system(Cap.NETWORK_RESET, Cap.DEFENDER))]
|
||
self.assertIn("quick_actions", keys)
|
||
self.assertIn("windows_settings", keys)
|
||
self.assertNotIn("quick_actions_basic", keys)
|
||
|
||
def test_a_system_without_them_gets_the_short_quick_actions_step_and_no_windows_group(self) -> None:
|
||
from ui.onboarding.steps import tour_steps_for
|
||
|
||
keys = [step.key for step in tour_steps_for(self._system())]
|
||
self.assertIn("quick_actions_basic", keys)
|
||
self.assertNotIn("quick_actions", keys)
|
||
self.assertNotIn("windows_settings", keys)
|
||
|
||
def test_the_variants_stand_in_the_same_place_so_the_chapter_order_is_the_same(self) -> None:
|
||
from ui.onboarding.steps import ALL_TOUR_STEPS
|
||
|
||
keys = [step.key for step in ALL_TOUR_STEPS]
|
||
self.assertEqual(keys.index("quick_actions_basic"), keys.index("quick_actions") + 1)
|
||
self.assertEqual(
|
||
{step.chapter for step in ALL_TOUR_STEPS if step.key in {"quick_actions", "quick_actions_basic"}}, {"control"}
|
||
)
|
||
|
||
def test_the_short_text_does_not_mention_the_windows_network_reset(self) -> None:
|
||
from app.ui_texts import TEXTS
|
||
|
||
for language in ("ru", "en"):
|
||
text = TEXTS["onboarding.step.quick_actions_basic.body"][language]
|
||
self.assertNotIn("Windows", text)
|
||
self.assertNotIn("Winsock", text)
|
||
self.assertIn("Winsock", TEXTS["onboarding.step.quick_actions.body"]["ru"])
|
||
|
||
def test_the_dns_steps_have_a_text_for_a_system_without_the_built_in_encrypted_dns(self) -> None:
|
||
from app.ui_texts import TEXTS
|
||
from platforms import Cap
|
||
from ui.onboarding.steps import ALL_TOUR_STEPS, tour_steps_for
|
||
|
||
with_proxy = [step.key for step in tour_steps_for(self._system(Cap.LOCAL_DNS_PROXY))]
|
||
without = [step.key for step in tour_steps_for(self._system())]
|
||
self.assertIn("dns_providers", with_proxy)
|
||
self.assertNotIn("dns_providers_basic", with_proxy)
|
||
self.assertIn("dns_providers_basic", without)
|
||
self.assertNotIn("dns_providers", without)
|
||
self.assertNotIn("dns_now", without)
|
||
keys = [step.key for step in ALL_TOUR_STEPS]
|
||
self.assertEqual(keys.index("dns_providers_basic"), keys.index("dns_providers") + 1)
|
||
self.assertIn("hosts_summary_basic", without)
|
||
self.assertNotIn("hosts_summary", without)
|
||
self.assertIn("hosts_summary", with_proxy)
|
||
for key in ("dns_now_basic", "dns_providers_basic", "hosts_summary_basic"):
|
||
for language in ("ru", "en"):
|
||
text = TEXTS[f"onboarding.step.{key}.body"][language]
|
||
self.assertNotIn("Windows", text)
|
||
self.assertNotIn("dnscrypt", text)
|
||
self.assertNotIn("(DoH)», серверы", TEXTS["onboarding.step.dns_providers_basic.body"]["ru"])
|
||
|
||
def test_the_running_tour_is_the_one_of_this_system(self) -> None:
|
||
# The tour is built when the module is first imported: either under the system's own platform or, in a test
|
||
# run, under the one the test setup gave extra capabilities (tests/conftest.py).
|
||
from platforms import _select, current
|
||
from ui.onboarding.steps import TOUR_STEPS, tour_steps_for
|
||
|
||
running = [step.key for step in TOUR_STEPS]
|
||
allowed = ([step.key for step in tour_steps_for(platform)] for platform in (_select(), current()))
|
||
self.assertIn(running, list(allowed))
|
||
|
||
|
||
class TourStepCatalogTests(unittest.TestCase):
|
||
def test_wiki_links_belong_to_real_steps(self) -> None:
|
||
from config.urls import ONBOARDING_WIKI_URLS
|
||
from ui.onboarding.steps import ALL_TOUR_STEPS
|
||
|
||
step_keys = {step.key for step in ALL_TOUR_STEPS}
|
||
self.assertEqual(set(ONBOARDING_WIKI_URLS) - step_keys, set())
|
||
for step in ALL_TOUR_STEPS:
|
||
self.assertEqual(step.wiki_url, ONBOARDING_WIKI_URLS.get(step.key, ""))
|
||
if step.wiki_url:
|
||
self.assertTrue(step.wiki_url.startswith("https://otukcszfwr.zapret.moe/"), step.key)
|
||
|
||
def test_tile_counter_step_stands_between_profiles_overview_and_profile_row(self) -> None:
|
||
from app.ui_texts import TEXTS as UI_TEXTS
|
||
from ui.onboarding.steps import TOUR_STEPS
|
||
|
||
keys = [step.key for step in TOUR_STEPS]
|
||
position = keys.index("profile_group")
|
||
self.assertEqual(keys[position - 1 : position + 2], ["profiles_list", "profile_group", "profile_row"])
|
||
self.assertEqual(TOUR_STEPS[position].page, "preset_setup")
|
||
|
||
# Главная мысль для новичка: включать все профили не нужно.
|
||
overview = UI_TEXTS["onboarding.step.profiles_list.body"]["ru"]
|
||
counter = UI_TEXTS["onboarding.step.profile_group.body"]["ru"]
|
||
row = UI_TEXTS["onboarding.step.profile_row.body"]["ru"]
|
||
self.assertIn("Включать все профили подряд не надо", overview)
|
||
self.assertIn("«3 из 5»", counter)
|
||
self.assertIn("включать их все обычно бесполезно", counter)
|
||
self.assertIn("Наведите мышь", counter)
|
||
self.assertIn("закрашенная — профиль включён", row)
|
||
self.assertNotIn("Hostlist или IPset", row)
|
||
|
||
def test_step_keys_are_unique_and_pages_exist_in_zapret2_mode(self) -> None:
|
||
from app.page_names import PageName
|
||
from ui.onboarding.steps import COMMON_TOUR_PAGES, MODE_TOUR_PAGES, TOUR_STEPS, TOUR_SUBPAGE_PARENTS
|
||
|
||
keys = [step.key for step in TOUR_STEPS]
|
||
self.assertEqual(len(keys), len(set(keys)))
|
||
pages = {**COMMON_TOUR_PAGES, **MODE_TOUR_PAGES[PageName.ZAPRET2_MODE_CONTROL]}
|
||
self.assertEqual(sorted({step.page for step in TOUR_STEPS if step.page} - set(pages)), [])
|
||
for child, parent in TOUR_SUBPAGE_PARENTS.items():
|
||
self.assertIn(child, pages)
|
||
self.assertIn(parent, pages)
|
||
# Общие страницы есть в каждом режиме, а фейки и разбор лога — только у winws2.
|
||
for mode_pages in MODE_TOUR_PAGES.values():
|
||
self.assertEqual(set(mode_pages) & set(COMMON_TOUR_PAGES), set())
|
||
self.assertNotIn("fakes_page", MODE_TOUR_PAGES[PageName.ZAPRET1_MODE_CONTROL])
|
||
self.assertNotIn("log_analyzer", MODE_TOUR_PAGES[PageName.ZAPRET1_MODE_CONTROL])
|
||
|
||
def test_every_step_belongs_to_a_named_chapter_and_chapters_do_not_mix(self) -> None:
|
||
from app.ui_texts import TEXTS
|
||
from ui.onboarding.steps import TOUR_STEPS
|
||
|
||
order: list[str] = []
|
||
for step in TOUR_STEPS:
|
||
self.assertTrue(step.chapter, step.key)
|
||
if not order or order[-1] != step.chapter:
|
||
order.append(step.chapter)
|
||
# Глава идёт одним куском: вернуться к уже пройденной нельзя.
|
||
self.assertEqual(len(order), len(set(order)))
|
||
self.assertEqual(order[0], "intro")
|
||
self.assertEqual(order[-1], "finish")
|
||
for chapter in order:
|
||
for language in ("ru", "en"):
|
||
self.assertTrue(str((TEXTS.get(f"onboarding.chapter.{chapter}") or {}).get(language) or "").strip(), chapter)
|
||
|
||
def test_tour_visits_the_pages_added_after_presets_and_profiles(self) -> None:
|
||
from ui.onboarding.steps import ALL_TOUR_STEPS
|
||
|
||
pages = {step.page for step in ALL_TOUR_STEPS}
|
||
for page in (
|
||
"fakes_page",
|
||
"dpi_settings",
|
||
"dns",
|
||
"custom_dns",
|
||
"hosts",
|
||
"hosts_file",
|
||
"telegram",
|
||
"telegram_advanced",
|
||
"blockcheck",
|
||
"log_analyzer",
|
||
"appearance",
|
||
"logs",
|
||
"about",
|
||
"updates",
|
||
):
|
||
self.assertIn(page, pages)
|
||
|
||
def test_every_step_has_title_and_body_in_both_languages(self) -> None:
|
||
from app.ui_texts import TEXTS
|
||
from ui.onboarding.steps import ALL_TOUR_STEPS
|
||
|
||
# Прямо по словарю: tr() подставил бы русский текст вместо пропавшего английского.
|
||
missing = []
|
||
for step in ALL_TOUR_STEPS:
|
||
for part in ("title", "body"):
|
||
key = f"onboarding.step.{step.key}.{part}"
|
||
for language in ("ru", "en"):
|
||
if not str((TEXTS.get(key) or {}).get(language) or "").strip():
|
||
missing.append(f"{key} [{language}]")
|
||
self.assertEqual(missing, [])
|
||
|
||
|
||
class TechniqueIllustrationTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _illustration(self, host):
|
||
from ui.onboarding.illustrations import TechniqueIllustration
|
||
|
||
illustration = TechniqueIllustration(host, tr_fn=lambda _key, default: default)
|
||
illustration.resize(532, illustration.height())
|
||
return illustration
|
||
|
||
def test_every_scene_draws_something_at_every_moment(self) -> None:
|
||
from ui.onboarding.illustrations import SCENES
|
||
|
||
host = QWidget()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
for key in SCENES:
|
||
illustration.set_scene(key)
|
||
for phase in (0.05, 0.3, 0.6, 0.86):
|
||
illustration.set_phase(phase)
|
||
image = illustration.grab().toImage()
|
||
colors = {image.pixel(x, y) for x in range(0, image.width(), 7) for y in range(0, image.height(), 7)}
|
||
self.assertGreater(len(colors), 3, f"{key} @ {phase}")
|
||
finally:
|
||
host.deleteLater()
|
||
|
||
def test_still_frame_shows_settled_scene(self) -> None:
|
||
# Без анимаций виден один кадр STATIC_PHASE: к нему все переходы
|
||
# (реплика, вспышка у сайта, падение подделок и мусора) уже закончились.
|
||
from ui.onboarding.illustrations import FADE_FROM, SCENES, STATIC_PHASE
|
||
|
||
host = QWidget()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
for width in (460, 532, 580):
|
||
illustration.resize(width, illustration.height())
|
||
for key in SCENES:
|
||
illustration.set_scene(key)
|
||
self.assertLessEqual(illustration.scene_times().settled, STATIC_PHASE, f"{key} @ {width}")
|
||
illustration.set_phase(STATIC_PHASE)
|
||
still = illustration.grab().toImage()
|
||
illustration.set_phase(FADE_FROM - 0.001)
|
||
self.assertEqual(still, illustration.grab().toImage(), f"{key} @ {width}")
|
||
finally:
|
||
host.deleteLater()
|
||
|
||
def test_tcpseg_junk_leads_one_packet_and_site_drops_it(self) -> None:
|
||
# seqovl: мусор приклеен в начало того же пакета. На схеме правее —
|
||
# значит раньше, поэтому мусор едет справа от данных, вплотную к ним,
|
||
# первым входит в проверку, а отбрасывает его уже сайт.
|
||
from ui.onboarding.illustrations import DISCARD, TRAVEL
|
||
|
||
host = QWidget()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.set_scene("tcpseg")
|
||
times = illustration.scene_times()
|
||
junk_arrival = times.starts[0] + TRAVEL
|
||
data_arrival = times.starts[1] + TRAVEL
|
||
self.assertLess(junk_arrival, data_arrival)
|
||
|
||
# У проверки: реплика звучит, когда в середине проверки мусор, а данные ещё не дошли.
|
||
frames = {frame.index: frame for frame in illustration.chip_frames(times.verdict)}
|
||
junk, data = frames[0], frames[1]
|
||
self.assertAlmostEqual(junk.x, illustration.width() / 2, delta=1.0)
|
||
self.assertLess(data.x, junk.x)
|
||
# Один пакет: половины слиты без просвета, не как отдельные пакеты.
|
||
self.assertTrue(junk.glued)
|
||
self.assertEqual((junk.flat, data.flat), ("left", "right"))
|
||
self.assertAlmostEqual(junk.x - data.x, (junk.width + data.width) / 2)
|
||
|
||
# После проверки мусор не гаснет по дороге, как подделка.
|
||
frames = {frame.index: frame for frame in illustration.chip_frames(junk_arrival - TRAVEL * 0.1)}
|
||
self.assertAlmostEqual(frames[0].alpha, 1.0)
|
||
self.assertAlmostEqual(frames[0].dy, 0.0)
|
||
|
||
# У сайта: мусор падает с дорожки, данные входят следом.
|
||
frames = {frame.index: frame for frame in illustration.chip_frames(junk_arrival + DISCARD * 0.5)}
|
||
self.assertGreater(frames[0].dy, 0.0)
|
||
self.assertFalse(frames[0].glued)
|
||
self.assertEqual(frames[1].flat, "")
|
||
self.assertEqual(illustration.chip_frames(max(junk_arrival + DISCARD, data_arrival) + 0.01), [])
|
||
finally:
|
||
host.deleteLater()
|
||
|
||
def test_separate_packets_keep_a_gap(self) -> None:
|
||
# Просвет на схеме = отдельные пакеты: подделка в fake не слита с настоящим.
|
||
from ui.onboarding.illustrations import CHIP_GAP
|
||
|
||
host = QWidget()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.set_scene("fake")
|
||
times = illustration.scene_times()
|
||
frames = {frame.index: frame for frame in illustration.chip_frames(times.starts[1] + 0.1)}
|
||
fake, real = frames[0], frames[1]
|
||
self.assertGreaterEqual(fake.x - real.x - (fake.width + real.width) / 2, CHIP_GAP)
|
||
self.assertEqual((fake.flat, real.flat, fake.glued), ("", "", False))
|
||
finally:
|
||
host.deleteLater()
|
||
|
||
def test_every_illustrated_step_uses_a_known_scene(self) -> None:
|
||
from ui.onboarding.illustrations import SCENES
|
||
from ui.onboarding.steps import TOUR_STEPS
|
||
|
||
illustrated = [step for step in TOUR_STEPS if step.illustration]
|
||
self.assertGreaterEqual(len(illustrated), 9)
|
||
for step in illustrated:
|
||
self.assertIn(step.illustration, SCENES, step.key)
|
||
|
||
def test_animation_runs_only_while_visible(self) -> None:
|
||
host = QWidget()
|
||
host.resize(600, 300)
|
||
host.show()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.set_scene("fake")
|
||
illustration.show()
|
||
with patch("ui.onboarding.illustrations.are_live_animations_enabled", return_value=True):
|
||
illustration.set_scene("multisplit")
|
||
self.assertTrue(illustration.is_animating())
|
||
illustration.hide()
|
||
self.assertFalse(illustration.is_animating())
|
||
finally:
|
||
host.close()
|
||
host.deleteLater()
|
||
|
||
def test_pause_button_freezes_frame_and_resumes_from_it(self) -> None:
|
||
from PyQt6.QtCore import Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
from ui.onboarding import illustrations
|
||
|
||
host = QWidget()
|
||
host.resize(600, 300)
|
||
host.show()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.show()
|
||
with patch("ui.onboarding.illustrations.are_live_animations_enabled", return_value=True):
|
||
illustration.set_scene("tcpseg")
|
||
button = illustration.pause_button
|
||
self.assertTrue(button.isVisible())
|
||
self.assertEqual(button.geometry().topRight(), illustration.rect().topRight())
|
||
|
||
illustration.set_phase(0.3)
|
||
QTest.mouseClick(button, Qt.MouseButton.LeftButton)
|
||
self.assertTrue(illustration.is_paused())
|
||
self.assertFalse(illustration.is_animating())
|
||
self.assertEqual(illustration.phase(), 0.3)
|
||
self.assertEqual(button.toolTip(), "Продолжить анимацию")
|
||
|
||
# Продолжение идёт с того же кадра, а не с начала круга.
|
||
QTest.mouseClick(button, Qt.MouseButton.LeftButton)
|
||
self.assertFalse(illustration.is_paused())
|
||
self.assertTrue(illustration.is_animating())
|
||
self.assertEqual(button.toolTip(), "Остановить анимацию")
|
||
with patch.object(illustration._clock, "elapsed", return_value=int(0.1 * illustrations.PERIOD_MS)):
|
||
illustration._on_tick()
|
||
self.assertAlmostEqual(illustration.phase(), 0.4, places=3)
|
||
|
||
# Следующий шаг: новая схема идёт сама, с начала.
|
||
illustration.set_paused(True)
|
||
illustration.set_scene("fake")
|
||
self.assertFalse(illustration.is_paused())
|
||
self.assertTrue(illustration.is_animating())
|
||
self.assertEqual(illustration.phase(), 0.0)
|
||
finally:
|
||
host.close()
|
||
host.deleteLater()
|
||
|
||
def test_pause_button_hidden_when_animations_are_off(self) -> None:
|
||
host = QWidget()
|
||
host.resize(600, 300)
|
||
host.show()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.show()
|
||
with patch("ui.onboarding.illustrations.are_live_animations_enabled", return_value=False):
|
||
illustration.set_scene("fake")
|
||
self.assertFalse(illustration.pause_button.isVisible())
|
||
illustration.set_paused(True)
|
||
self.assertFalse(illustration.is_paused())
|
||
finally:
|
||
host.close()
|
||
host.deleteLater()
|
||
|
||
def test_without_animations_shows_still_frame_with_result(self) -> None:
|
||
from ui.onboarding.illustrations import STATIC_PHASE
|
||
|
||
host = QWidget()
|
||
host.resize(600, 300)
|
||
host.show()
|
||
try:
|
||
illustration = self._illustration(host)
|
||
illustration.show()
|
||
with patch("ui.onboarding.illustrations.are_live_animations_enabled", return_value=False):
|
||
illustration.set_scene("fake")
|
||
self.assertFalse(illustration.is_animating())
|
||
self.assertEqual(illustration.phase(), STATIC_PHASE)
|
||
finally:
|
||
host.close()
|
||
host.deleteLater()
|
||
|
||
def test_card_shows_illustration_only_on_its_steps(self) -> None:
|
||
from app.page_names import PageName
|
||
from ui.onboarding.overlay import CARD_WIDTH, HERO_CARD_WIDTH, OnboardingOverlay
|
||
from ui.onboarding.steps import TourContext, TourStep, _page_target
|
||
|
||
window, page = _build_window()
|
||
window.resize(900, 760)
|
||
window.show()
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
steps = (
|
||
TourStep("start", _page_target("start"), page="control"),
|
||
TourStep("technique_fake", illustration="fake"),
|
||
)
|
||
overlay = OnboardingOverlay(window, context, steps)
|
||
try:
|
||
overlay.start()
|
||
illustration = overlay._card.illustration
|
||
self.assertTrue(illustration.isHidden())
|
||
self.assertEqual(overlay.card_target_size().width(), CARD_WIDTH)
|
||
overlay.go_next()
|
||
self.assertFalse(illustration.isHidden())
|
||
self.assertEqual(illustration.scene_key(), "fake")
|
||
self.assertEqual(overlay.card_target_size().width(), HERO_CARD_WIDTH)
|
||
overlay.go_back()
|
||
self.assertTrue(illustration.isHidden())
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class _FocusGrabbingPage(QWidget):
|
||
"""Как редактор пресета: после открытия сам забирает фокус таймером."""
|
||
|
||
def __init__(self, parent=None) -> None:
|
||
from PyQt6.QtWidgets import QPlainTextEdit
|
||
|
||
super().__init__(parent)
|
||
layout = QVBoxLayout(self)
|
||
self.editor = QPlainTextEdit(self)
|
||
self.editor.setPlainText("--lua-desync=fake")
|
||
layout.addWidget(self.editor)
|
||
self.values = {"count": "7"}
|
||
|
||
def onboarding_target(self, name):
|
||
return self.editor if name == "editor" else None
|
||
|
||
def onboarding_text_values(self, _name):
|
||
return dict(self.values)
|
||
|
||
def grab_focus_later(self) -> None:
|
||
from PyQt6.QtCore import QTimer
|
||
|
||
QTimer.singleShot(0, self.editor.setFocus)
|
||
|
||
|
||
class OnboardingCardBehaviourTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _overlay(self, steps, page_cls=_FocusGrabbingPage):
|
||
from PyQt6.QtTest import QTest
|
||
|
||
from app.page_names import PageName
|
||
from ui.onboarding.overlay import OnboardingOverlay
|
||
from ui.onboarding.steps import TourContext
|
||
|
||
window = QWidget()
|
||
window.resize(900, 700)
|
||
layout = QVBoxLayout(window)
|
||
page = page_cls(window)
|
||
layout.addWidget(page)
|
||
|
||
class Host:
|
||
def show_page(self, _name, allow_internal=False):
|
||
return True
|
||
|
||
def get_loaded_page(self, _name):
|
||
return page
|
||
|
||
def current_page(self):
|
||
return page
|
||
|
||
window.ui_session = SimpleNamespace(nav_items={}, nav_header_by_group={}, nav_headers=[], page_host=Host())
|
||
window.show()
|
||
window.activateWindow()
|
||
QTest.qWaitForWindowActive(window, 1000)
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
overlay = OnboardingOverlay(window, context, steps)
|
||
return window, page, overlay
|
||
|
||
def test_arrows_keep_working_when_page_takes_focus(self) -> None:
|
||
from PyQt6.QtCore import Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("welcome", hero=True),
|
||
TourStep("editor", _page_target("editor"), page="control"),
|
||
TourStep("finish", hero=True),
|
||
)
|
||
window, page, overlay = self._overlay(steps)
|
||
try:
|
||
overlay.start()
|
||
overlay.go_next()
|
||
page.grab_focus_later()
|
||
for _ in range(5):
|
||
QApplication.processEvents()
|
||
focus = QApplication.focusWidget()
|
||
self.assertTrue(focus is not None and overlay.isAncestorOf(focus))
|
||
QTest.keyClick(focus, Qt.Key.Key_A)
|
||
self.assertEqual(page.editor.toPlainText(), "--lua-desync=fake")
|
||
QTest.keyClick(QApplication.focusWidget(), Qt.Key.Key_Right)
|
||
self.assertEqual(overlay.current_step_key(), "finish")
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_click_on_a_chapter_segment_opens_its_first_step(self) -> None:
|
||
from PyQt6.QtCore import QPoint, Qt
|
||
from PyQt6.QtTest import QTest
|
||
|
||
from ui.onboarding.steps import TourStep
|
||
|
||
# Шесть глав по десять шагов: отрезков шесть, а не шестьдесят точек.
|
||
steps = tuple(TourStep(f"step_{index}", hero=True, chapter=f"chapter_{index // 10}") for index in range(60))
|
||
window, _page, overlay = self._overlay(steps)
|
||
try:
|
||
overlay.start()
|
||
for _ in range(30):
|
||
QApplication.processEvents()
|
||
bar = overlay._card.chapter_bar
|
||
rects = bar.segment_rects()
|
||
self.assertEqual(len(rects), 6)
|
||
self.assertLessEqual(rects[-1].right(), bar.width() + 0.5)
|
||
# Нажимается вся высота строки, а не тонкая полоска.
|
||
self.assertGreaterEqual(min(rect.width() for rect in rects), 40)
|
||
self.assertEqual(rects[0].height(), bar.height())
|
||
QTest.mouseClick(bar, Qt.MouseButton.LeftButton, pos=QPoint(int(rects[4].center().x()), 2))
|
||
self.assertEqual(overlay.current_step_key(), "step_40")
|
||
# Щелчок в промежуток между отрезками тоже куда-то ведёт: мимо не нажать.
|
||
between = int((rects[1].right() + rects[2].left()) / 2)
|
||
QTest.mouseClick(bar, Qt.MouseButton.LeftButton, pos=QPoint(between, bar.height() - 2))
|
||
self.assertIn(overlay.current_step_key(), ("step_10", "step_20"))
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_opacity_effect_is_off_once_text_is_fully_shown(self) -> None:
|
||
import time
|
||
|
||
from ui.onboarding.steps import TourStep
|
||
|
||
window, _page, overlay = self._overlay((TourStep("welcome", hero=True), TourStep("next", hero=True)))
|
||
try:
|
||
overlay.start()
|
||
deadline = time.monotonic() + 2.0
|
||
while time.monotonic() < deadline and overlay._card.content_effect.isEnabled():
|
||
QApplication.processEvents()
|
||
time.sleep(0.01)
|
||
self.assertFalse(overlay._card.content_effect.isEnabled())
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_live_values_fill_the_text_and_missing_ones_become_a_dash(self) -> None:
|
||
from ui.onboarding.overlay import _fill_placeholders, _unbreakable_options
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
self.assertEqual(_fill_placeholders("{count} и {example}", {"count": "3"}), "3 и —")
|
||
self.assertEqual(_unbreakable_options("Строка --lua-desync тут"), "Строка \u2011\u2011lua\u2011desync тут")
|
||
|
||
steps = (TourStep("preset_blobs", _page_target("editor"), page="control", text_key="section:blobs"),)
|
||
window, page, overlay = self._overlay(steps)
|
||
page.values = {"count": "42", "example": "tls_vk"}
|
||
try:
|
||
overlay.start()
|
||
body = overlay._card.body_label.text()
|
||
self.assertIn("42", body)
|
||
self.assertIn("tls_vk", body)
|
||
self.assertNotIn("{", body)
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class _TallGridPage(QScrollArea):
|
||
"""Прокручиваемая страница с одной высокой «сеткой»: цель — прямоугольник внутри неё."""
|
||
|
||
GRID_HEIGHT = 3000
|
||
|
||
def __init__(self, parent=None) -> None:
|
||
super().__init__(parent)
|
||
self.setWidgetResizable(True)
|
||
content = QWidget(self)
|
||
layout = QVBoxLayout(content)
|
||
self.panel = QPushButton("Панель над сеткой", content)
|
||
self.panel.setFixedHeight(60)
|
||
layout.addWidget(self.panel)
|
||
self.grid = QWidget(content)
|
||
self.grid.setFixedHeight(self.GRID_HEIGHT)
|
||
layout.addWidget(self.grid)
|
||
self.late_button = QPushButton("Появится позже", content)
|
||
self.late_button.hide()
|
||
layout.addWidget(self.late_button)
|
||
self.setWidget(content)
|
||
self.tile_rect = QRect(20, 2400, 300, 90)
|
||
|
||
def onboarding_target(self, name):
|
||
if name == "tile":
|
||
return (self.grid, self.tile_rect)
|
||
if name == "late":
|
||
return self.late_button
|
||
if name == "panel":
|
||
return self.panel
|
||
if name == "grid":
|
||
return self.grid
|
||
return None
|
||
|
||
|
||
class OnboardingChapterAndScrollTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _overlay(self, steps, page_cls=_FakePage):
|
||
from app.page_names import PageName
|
||
from ui.onboarding import overlay as overlay_module
|
||
from ui.onboarding.steps import TourContext
|
||
|
||
window = QWidget()
|
||
self.addCleanup(window.deleteLater)
|
||
window.resize(900, 640)
|
||
layout = QVBoxLayout(window)
|
||
page = page_cls(window)
|
||
layout.addWidget(page)
|
||
|
||
class Host:
|
||
def show_page(self, _name, allow_internal=False):
|
||
return True
|
||
|
||
def get_loaded_page(self, _name):
|
||
return page
|
||
|
||
def current_page(self):
|
||
return page
|
||
|
||
window.ui_session = SimpleNamespace(nav_items={}, nav_header_by_group={}, nav_headers=[], page_host=Host())
|
||
window.show()
|
||
QApplication.processEvents()
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
with patch.object(overlay_module, "are_live_animations_enabled", return_value=False):
|
||
overlay = overlay_module.OnboardingOverlay(window, context, steps)
|
||
self.addCleanup(lambda: overlay.finish("skipped", immediate=True))
|
||
return window, page, overlay
|
||
|
||
def test_counter_and_segment_hint_name_the_chapter(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (
|
||
TourStep("start", _page_target("start"), page="control", chapter="control"),
|
||
TourStep("status", _page_target("start"), page="control", chapter="control"),
|
||
TourStep("preset", _page_target("start"), page="control"),
|
||
)
|
||
_window, _page, overlay = self._overlay(steps)
|
||
overlay.start()
|
||
|
||
self.assertEqual(overlay._card.counter_label.text(), "Главная страница · Шаг 1 из 3")
|
||
first, second = overlay._card.chapter_bar.chapters()
|
||
self.assertEqual((first.first, first.count, first.hint), (0, 2, "Главная страница · шагов: 2"))
|
||
# Шаги без главы — отдельный отрезок без подсказки, счётчик у них как раньше.
|
||
self.assertEqual((second.first, second.count, second.hint), (2, 1, ""))
|
||
overlay.go_to(2)
|
||
self.assertEqual(overlay._card.counter_label.text(), "Шаг 3 из 3")
|
||
|
||
def test_chapters_of_the_whole_tour_stay_easy_to_click_in_a_narrow_card(self) -> None:
|
||
from ui.onboarding.overlay import TourChapter, _ChapterBar
|
||
from ui.onboarding.steps import TOUR_STEPS
|
||
|
||
chapters: list[TourChapter] = []
|
||
for index, step in enumerate(TOUR_STEPS):
|
||
if chapters and chapters[-1].title == step.chapter:
|
||
chapters[-1] = TourChapter(step.chapter, chapters[-1].first, chapters[-1].count + 1)
|
||
else:
|
||
chapters.append(TourChapter(step.chapter, index, 1))
|
||
self.assertGreater(len(TOUR_STEPS), 90)
|
||
self.assertLessEqual(len(chapters), 12)
|
||
bar = _ChapterBar()
|
||
self.addCleanup(bar.deleteLater)
|
||
bar.set_chapters(chapters)
|
||
|
||
# 212 точек — строка в самой узкой карточке (окно шириной под 300).
|
||
for width in (212, 452):
|
||
bar.resize(width, bar.HEIGHT)
|
||
rects = bar.segment_rects()
|
||
self.assertLessEqual(rects[-1].right(), width + 0.5)
|
||
self.assertGreaterEqual(min(rect.width() for rect in rects), 12, width)
|
||
# Глава из одного шага («Финиш») нажимается так же, как длинная.
|
||
self.assertAlmostEqual(rects[-1].width(), rects[0].width(), places=3)
|
||
self.assertEqual(bar.chapter_at(rects[-1].center().x()), len(chapters) - 1)
|
||
|
||
# Пройденные главы закрашены целиком, текущая — по доле шагов, дальние пустые.
|
||
diagnostics = next(index for index, chapter in enumerate(chapters) if chapter.title == "diagnostics")
|
||
bar.set_step(chapters[diagnostics].first)
|
||
bar.advance(16.0, animated=False)
|
||
self.assertEqual(bar.current_chapter(), diagnostics)
|
||
self.assertEqual(bar.fill_share(diagnostics - 1), 1.0)
|
||
self.assertAlmostEqual(bar.fill_share(diagnostics), 1 / chapters[diagnostics].count, places=6)
|
||
self.assertEqual(bar.fill_share(diagnostics + 1), 0.0)
|
||
|
||
def test_tile_deep_in_a_tall_grid_is_scrolled_into_view(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (TourStep("tile", _page_target("tile"), page="control"),)
|
||
window, page, overlay = self._overlay(steps, _TallGridPage)
|
||
overlay.start()
|
||
overlay._on_frame()
|
||
|
||
tile_top = page.grid.mapTo(window, page.tile_rect.topLeft()).y()
|
||
self.assertGreater(tile_top, 0)
|
||
self.assertLess(tile_top + page.tile_rect.height(), window.height())
|
||
self.assertIsNotNone(overlay._hole)
|
||
|
||
def test_target_that_slid_under_the_edge_is_brought_back_whole(self) -> None:
|
||
"""Страница сама прокрутилась после входа в шаг — от панели осталась полоска."""
|
||
from ui.onboarding.overlay import HOLE_PADDING
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (TourStep("panel", _page_target("panel"), page="control"),)
|
||
_window, page, overlay = self._overlay(steps, _TallGridPage)
|
||
overlay.start()
|
||
overlay._on_frame()
|
||
whole = page.panel.height() + 2 * HOLE_PADDING
|
||
self.assertAlmostEqual(overlay._hole.height(), whole, delta=1)
|
||
|
||
page.verticalScrollBar().setValue(page.panel.y() + page.panel.height() - 6)
|
||
self.assertLess(page.panel.visibleRegion().boundingRect().height(), 10)
|
||
overlay._on_frame()
|
||
|
||
self.assertEqual(page.panel.visibleRegion().boundingRect().height(), page.panel.height())
|
||
self.assertAlmostEqual(overlay._hole.height(), whole, delta=1)
|
||
|
||
def test_target_taller_than_the_page_is_shown_from_its_top_and_lit_only_where_seen(self) -> None:
|
||
from ui.onboarding.overlay import HOLE_PADDING
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (TourStep("grid", _page_target("grid"), page="control"),)
|
||
window, page, overlay = self._overlay(steps, _TallGridPage)
|
||
# Под страницей — полоса окна, которая к ней не относится.
|
||
footer = QPushButton("Низ окна", window)
|
||
footer.setFixedHeight(200)
|
||
window.layout().addWidget(footer)
|
||
QApplication.processEvents()
|
||
overlay.start()
|
||
overlay._on_frame()
|
||
|
||
# Qt сам поставил бы в центр середину сетки, и её начало уехало бы за край.
|
||
top = page.grid.mapTo(page.viewport(), QPoint(0, 0)).y()
|
||
self.assertGreaterEqual(top, 0)
|
||
self.assertLessEqual(top, 16)
|
||
# Окошко — только видимая часть сетки: на полосу под страницей оно не заходит.
|
||
page_bottom = page.viewport().mapTo(window, QPoint(0, page.viewport().height())).y() - overlay.y()
|
||
self.assertLessEqual(overlay._hole.bottom(), page_bottom + HOLE_PADDING + 1)
|
||
self.assertLess(overlay._hole.bottom(), footer.y() - overlay.y() + footer.height() / 2)
|
||
|
||
def test_target_that_appears_later_below_the_window_is_scrolled_to(self) -> None:
|
||
from ui.onboarding.steps import TourStep, _page_target
|
||
|
||
steps = (TourStep("late", _page_target("late"), page="control", target_optional=True),)
|
||
_window, page, overlay = self._overlay(steps, _TallGridPage)
|
||
overlay.start()
|
||
overlay._on_frame()
|
||
self.assertIsNone(overlay._hole)
|
||
|
||
page.late_button.show()
|
||
QApplication.processEvents()
|
||
overlay._on_frame()
|
||
|
||
self.assertIsNotNone(overlay._hole)
|
||
self.assertGreater(page.verticalScrollBar().value(), 0)
|
||
|
||
|
||
class OnboardingDecorTests(unittest.TestCase):
|
||
"""Полоска прогресса сверху и перетекающие точки."""
|
||
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def _overlay(self, count: int, *, animated: bool):
|
||
from app.page_names import PageName
|
||
from ui.onboarding import overlay as overlay_module
|
||
from ui.onboarding.steps import TourContext, TourStep
|
||
|
||
window, page = _build_window()
|
||
window.show()
|
||
context = TourContext(
|
||
window=window,
|
||
control_page_name=PageName.ZAPRET2_MODE_CONTROL,
|
||
pages={"control": PageName.ZAPRET2_MODE_CONTROL},
|
||
current_page=page,
|
||
)
|
||
steps = tuple(TourStep(f"step_{index}", hero=True) for index in range(count))
|
||
with patch.object(overlay_module, "are_live_animations_enabled", return_value=animated):
|
||
overlay = overlay_module.OnboardingOverlay(window, context, steps)
|
||
overlay.start()
|
||
return window, overlay
|
||
|
||
@staticmethod
|
||
def _run(overlay, seconds: float) -> None:
|
||
import time
|
||
|
||
deadline = time.monotonic() + seconds
|
||
while time.monotonic() < deadline:
|
||
QApplication.processEvents()
|
||
time.sleep(0.005)
|
||
|
||
def test_progress_glides_to_the_new_share_and_back(self) -> None:
|
||
window, overlay = self._overlay(4, animated=True)
|
||
card = overlay._card
|
||
try:
|
||
self._run(overlay, 1.6)
|
||
self.assertAlmostEqual(card.progress(), 0.25, places=3)
|
||
overlay.go_next()
|
||
overlay.go_next()
|
||
self._run(overlay, 0.05)
|
||
self.assertGreater(card.progress(), 0.25)
|
||
self.assertLess(card.progress(), 0.75)
|
||
self._run(overlay, 1.6)
|
||
self.assertAlmostEqual(card.progress(), 0.75, places=3)
|
||
overlay.go_back()
|
||
self._run(overlay, 1.6)
|
||
self.assertAlmostEqual(card.progress(), 0.5, places=3)
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_without_animations_everything_is_in_place_at_once(self) -> None:
|
||
window, overlay = self._overlay(5, animated=False)
|
||
try:
|
||
overlay.go_to(3)
|
||
self.assertAlmostEqual(overlay._card.progress(), 0.8, places=6)
|
||
overlay._on_frame()
|
||
self.assertEqual(overlay._card.chapter_bar.progress(), 4.0)
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
def test_chapter_fill_flows_to_a_far_step(self) -> None:
|
||
window, overlay = self._overlay(12, animated=True)
|
||
bar = overlay._card.chapter_bar
|
||
try:
|
||
self._run(overlay, 0.5)
|
||
self.assertEqual(bar.progress(), 1.0)
|
||
overlay.go_to(9)
|
||
self._run(overlay, 0.04)
|
||
# Заливка дотекает до нового шага, а не прыгает.
|
||
self.assertGreater(bar.progress(), 1.0)
|
||
self.assertLess(bar.progress(), 10.0)
|
||
self._run(overlay, 1.5)
|
||
self.assertEqual(bar.progress(), 10.0)
|
||
# Тур без глав — один отрезок на всю ширину, как обычная полоса хода.
|
||
self.assertEqual(len(bar.segment_rects()), 1)
|
||
self.assertAlmostEqual(bar.fill_share(0), 10 / 12, places=6)
|
||
finally:
|
||
overlay.finish("skipped", immediate=True)
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
class StartOnboardingTourTests(unittest.TestCase):
|
||
def setUp(self) -> None:
|
||
_app()
|
||
|
||
def test_automatic_start_waits_for_visible_window(self) -> None:
|
||
from ui.onboarding import start_onboarding_tour
|
||
|
||
window, _page = _build_window()
|
||
try:
|
||
self.assertFalse(start_onboarding_tour(window, automatic=True))
|
||
finally:
|
||
window.deleteLater()
|
||
|
||
def test_manual_replay_starts_and_second_call_reuses_running_tour(self) -> None:
|
||
from ui.onboarding import find_onboarding_overlay, start_onboarding_tour
|
||
|
||
window, _page = _build_window()
|
||
window.show()
|
||
try:
|
||
self.assertTrue(start_onboarding_tour(window))
|
||
overlay = find_onboarding_overlay(window)
|
||
self.assertIsNotNone(overlay)
|
||
self.assertTrue(start_onboarding_tour(window))
|
||
self.assertIs(find_onboarding_overlay(window), overlay)
|
||
finally:
|
||
window.close()
|
||
window.deleteLater()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|