"""Functional fake Tk widgets for the gate's display-free tests. Extracted from ``conftest.py`` purely for size: the widget tree the gate builds now spans several modules plus ``gatelock``, and the fakes grew past this repo's 500-line file cap when the scroll viewport and the radio-button unit selector were added. Stays under ``tests/`` deliberately. It was briefly moved into the package to satisfy the ``test_*.py`` naming hook, but that lost the ruff ``ARG`` exemption that ``**/tests/**`` already grants -- and a fake widget's whole job is to accept arguments it ignores. Weakening ruff for package code to accommodate test scaffolding is the wrong trade; excluding one clearly-named support file from a naming convention is the cheaper one. The fakes are *functional* where behaviour matters -- selecting a radio button really sets its variable and fires its command, and the canvas really tracks a scroll offset -- so a test can drive the gate the way a keyboard user now can, rather than merely asserting that a widget was constructed. """ from __future__ import annotations import tkinter as tk from types import SimpleNamespace from diet_guard.tests._tk_fakes_canvas import FakeCanvas, FakeScrollbar from diet_guard.tests._tk_fakes_containers import ( FakeNotebook, FakeRadiobutton, FakeStyle, FakeWidget, ) # Imported by name so `from _tk_fakes import X` keeps working for every fake, # and so `_gate_fixtures`'s `_FAKE_TK`/`_FAKE_TTK` import has one home. Listed # explicitly (rather than left as incidental imports) because ruff would # otherwise strip the re-exports as unused -- and the identity assertion in # `test_gate_tk_modules.py` is what catches it if one ever goes missing. __all__ = [ "_FAKE_TK", "_FAKE_TTK", "FakeCanvas", "FakeEntry", "FakeListbox", "FakeNotebook", "FakeRadiobutton", "FakeScrollbar", "FakeStyle", "FakeText", "FakeVar", "FakeWidget", "_FakeTclError", ] class _FakeTclError(tk.TclError): """Stand-in for ``tkinter.TclError`` (a real, catchable exception). Subclasses the *real* ``tkinter.TclError`` rather than ``Exception``. Not every module that catches a dead-widget error is in the fake-tk patch set -- ``_gatelock_widgetgroups`` deliberately is not, since it constructs no widgets -- so its ``contextlib.suppress(tk.TclError)`` refers to the genuine class. With a bare ``Exception`` base the fake escaped that suppression, meaning the "a monitor vanished mid-update" paths were only ever exercised against the real error and would have raised through the gate in a fake-tk test. Inheriting keeps both spellings catchable. """ class FakeVar: """A functional ``StringVar``: stores and returns a string.""" def __init__(self, master: object = None, value: str = "") -> None: self._value = value def get(self) -> str: return self._value def set(self, value: str) -> None: self._value = value class FakeEntry: """A functional one-line entry (delete clears, insert appends). ``configure``/``config`` record their kwargs into ``configured``, so a test can assert on a read-only/editable state toggle the same way it would with :class:`FakeWidget`. """ def __init__(self, *args: object, **kwargs: object) -> None: self._value = "" self.configured: dict[str, object] = dict(kwargs) def get(self) -> str: return self._value def delete(self, first: object, last: object = None) -> None: self._value = "" def insert(self, index: object, text: str) -> None: self._value += text def pack(self, *args: object, **kwargs: object) -> FakeEntry: return self def bind(self, *args: object, **kwargs: object) -> None: pass def configure(self, *args: object, **kwargs: object) -> None: self.configured.update(kwargs) config = configure def focus_set(self) -> None: pass def focus_force(self) -> None: pass class FakeText(FakeEntry): """A functional multi-line text box (``get`` ignores the index range).""" def get(self, start: object = None, end: object = None) -> str: return self._value class FakeListbox: """A functional listbox tracking items and the current selection.""" def __init__(self, *args: object, **kwargs: object) -> None: self._items: list[str] = [] self._sel: tuple[int, ...] = () def delete(self, first: object, last: object = None) -> None: self._items = [] def insert(self, index: object, text: str) -> None: self._items.append(text) def curselection(self) -> tuple[int, ...]: return self._sel def selection_set(self, index: int) -> None: self._sel = (index,) def selection_clear(self, first: object, last: object = None) -> None: self._sel = () def pack(self, *args: object, **kwargs: object) -> FakeListbox: return self def bind(self, *args: object, **kwargs: object) -> None: pass _FAKE_TK = SimpleNamespace( END="end", TclError=_FakeTclError, StringVar=FakeVar, Frame=FakeWidget, Label=FakeWidget, Button=FakeWidget, OptionMenu=FakeWidget, Radiobutton=FakeRadiobutton, Entry=FakeEntry, Text=FakeText, Listbox=FakeListbox, Canvas=FakeCanvas, Scrollbar=FakeScrollbar, Misc=FakeWidget, Event=object, ) _FAKE_TTK = SimpleNamespace(Notebook=FakeNotebook, Style=FakeStyle) # Every mixin module the gate window is built from imports ``tkinter`` # independently; all of them must see the fake so ``tk.TclError`` etc. are the # catchable ``_FakeTclError`` everywhere a test raises it.