#!/usr/bin/env python3 """INTERACTION module — FastTimes (intermittent-fasting tracker). Owns EFFECT-BY-CONSEQUENCE on user DATA: CRUD lifecycle (create a fast / a profile and read it back), multi-step sequences (3+ dependent actions), multi- record integrity (N records survive a mutation to one), long-press context menus (SOLE owner), and — the highest-value assertion — DATA persistence across process death. Every test drives the running original through the real user path, then reads the consequence out of a FRESH ui() and asserts it equals what was observed. CEDES to sibling lanes: a toggle's checked bit / settings persistence -> states; a computed value -> computation; the exact label wording -> text; whether a screen is reachable -> navigation; view-tree shape -> structure. Data model (verified live on the original): * A completed fast is a HISTORY record: start the debug "Test Timer" goal cell (a 10-second fast), wait ~11s for "Goal Reached!", tap "End Fast" -> the "Fast Complete!" summary modal (5 clickable star Views + Save) -> Save. The Dashboard "Fasts" count increments and the fast lands in History (Room DB) and survives process death. * A profile is created from Manage Profiles -> "Add Profile" FAB -> a dialog with 3 EditText (Profile Name / Description / Duration) + Save; the new card appears in "Other Profiles". Save's clickable parent is disabled until a name is typed. * Long-pressing a profile card reveals an "Edit | Favourite | Delete" button group; "Favourite" moves the card into the "Favourite Fast" section. Compose renders as android.view.View / TextView with NO resource-ids, so every target and every read-back key is a visible text / content-desc / a clickable View located by bounds. VLM budget for this lane = 8 (visual DATA states unreadable from the dump): the summary-modal 4-filled-star row, the Daily-Details 4-green-star rating, the Edit-Fast 4-green-star rating, the long-press outlined card, the populated Favourite Fast card, the newly created profile card in the grid, the running active-fast ring after a process kill, and the multi-record history list. SAFETY: never taps "Delete" / "Delete Fast" (destructive); every exploratory tap goes through safe_tap(). The Add Profile dialog is Compose and dismisses on an outside-tap / BACK, so the kit's hide_keyboard() would close it — this module therefore taps the dialog's Save control DIRECTLY with the keyboard up (verified), and never sends a raw ESCAPE keyevent. Run: python3 test_android_interaction.py """ import os import sys sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from android_testgen_kit import * # noqa: F403,E402 require_kit(1) RESULTS_DIR = sys.argv[2] if len(sys.argv) > 2 else RESULTS_DIR # noqa: F405 MARK = "kitprofZ" # distinctive marker for a created profile record # ── Portable launcher (LeakCanary registers a 2nd LAUNCHER activity; monkey opens # it ~half the time). Resolve THIS package's real MainActivity at runtime. ────── def _main_component(): out = adb_shell("cmd", "package", "query-activities", "--brief", "-a", "android.intent.action.MAIN", "-c", "android.intent.category.LAUNCHER") cands = [l.strip() for l in out.splitlines() if (PACKAGE + "/") in l] good = [c for c in cands if "leakcanary" not in c.lower()] return (good or cands or [""])[0] def open_main(): """Force-stop then launch the REAL MainActivity (never LeakCanary).""" force_stop() comp = _main_component() if comp: adb_shell("am", "start", "-n", comp) else: launch_app() settle("launch") wait_for_foreground() if "leakcanary" in get_current_activity().lower() and comp: adb_shell("am", "start", "-n", comp) settle("launch") def open_main_clear(): """Virgin state: wipe data (no active fast, empty history), then open Main.""" clear_data() open_main() def kill_and_reopen(): """Process-death probe WITHOUT monkey: force-stop the app, then relaunch the real MainActivity. An in-memory-only recreation cannot survive this.""" force_stop() settle("key") open_main() # ── Domain helpers ─────────────────────────────────────────────────────────── def _dismiss_notif_rationale(): """The first-run "Notification Preferences" rationale appears on the first goal tap after clear_data(). Dismiss it with a NON-destructive choice (the choice is irrelevant to the data operations under test). Returns True if it was shown.""" nodes = ui() if not find_node(nodes, text="Notification Preferences"): return False for label in ("No Notifications", "Skip", "Not Now", "Enable Notifications"): n = find_node(nodes, text=label) if n and is_safe(n): tap_node(n) settle("tap") return True return False def _on_dashboard(nodes=None): nodes = ui() if nodes is None else nodes return find_node(nodes, text="Set your goal") is not None def _fasts_count(nodes=None): """Read the integer under the Dashboard 'Fasts' stat blob (the record count). Returns int or None. The number TextView sits directly below the 'Fasts' label and roughly x-aligned with it.""" nodes = ui() if nodes is None else nodes lbl = find_node(nodes, text="Fasts") if not lbl or "_bounds" not in lbl: return None lx = lbl["_center"][0] ly2 = lbl["_bounds"][3] best = None for n in nodes: t = n.get("text", "").strip() b = n.get("_bounds") if not b or not t.isdigit(): continue if b[1] > ly2 and (b[1] - ly2) < 160 and abs(n["_center"][0] - lx) < 140: if best is None or b[1] < best[1]: best = (int(t), b[1]) return best[0] if best else None def _start_goal(cell_text): """From a CLEAN dashboard, tap a goal cell by its name and land on the ACTIVE-FAST card (desc='End Fast'). Handles the first-run notification rationale. Returns True on success.""" cell = find_node(ui(), text=cell_text) if not cell: return False tap_node(cell) settle("tap") _dismiss_notif_rationale() if find_node(ui(), content_desc="End Fast"): return True # the rationale dialog may have consumed the first tap; retry the cell once cell = find_node(ui(), text=cell_text) if cell: tap_node(cell) settle("tap") _dismiss_notif_rationale() return find_node(ui(), content_desc="End Fast") is not None def _wait_goal_reached(polls=16): """Poll until the Test Timer flips to 'Goal Reached!' (~11s). Bounded so a slow emulator never hangs the suite. Returns whether it flipped.""" for _ in range(polls): if find_node(ui(), text="Goal Reached!"): return True settle("tap") return False def _modal_star_views(): """The 5 clickable rating stars in the 'Fast Complete!' summary modal: they are empty-text clickable android.view.View nodes laid out in ONE horizontal row (near-square, same y-band). Returned x-sorted, so index 3 == the 4th star.""" nodes = ui() clk = [n for n in nodes if n.get("class", "").endswith("view.View") and n.get("clickable") == "true" and not n.get("text", "").strip() and not n.get("content-desc", "").strip() and "_bounds" in n] # keep only near-square cells (a star), then the most populous single y-row stars = [] for n in clk: x1, y1, x2, y2 = n["_bounds"] w, h = x2 - x1, y2 - y1 if w < 40 or h < 40: continue if 0.6 <= w / h <= 1.7: stars.append(n) if len(stars) < 5: return [] # group by y-centre band; pick the band with the most members (the star row) stars.sort(key=lambda n: n["_center"][1]) rows, cur = [], [stars[0]] for n in stars[1:]: if abs(n["_center"][1] - cur[-1]["_center"][1]) <= 30: cur.append(n) else: rows.append(cur) cur = [n] rows.append(cur) row = max(rows, key=len) row.sort(key=lambda n: n["_center"][0]) return row def _tap_summary_save(): """Tap 'Save' in the summary modal. 'Save' is a non-clickable TextView; its centre lies inside the clickable parent View, so tapping the text centre works. """ n = find_node(ui(), text="Save") return tap_node(n) if n else False def save_test_timer_fast(): """Complete + SAVE one Test Timer fast from a clean dashboard (rating it 4 stars), landing back on the Dashboard with the fast persisted. Returns True on success.""" if not _start_goal("Test Timer"): return False _wait_goal_reached() ef = find_node(ui(), content_desc="End Fast") if not ef: return False tap_node(ef) settle("tap") stars = _modal_star_views() if len(stars) >= 4: tap_node(stars[3]) # 4th star settle("tap") if not _tap_summary_save(): return False settle("tap") return _on_dashboard() def open_history_via_link(): """Dashboard -> History pane via the 'Go to History' arrow. Returns True when the month header is showing.""" n = find_node(ui(), content_desc="Go to History") if not n: return False tap_node(n) settle("tap") return find_node(ui(), text="August 2026") is not None def open_daily_details_day5(): """From the History pane, open day-5's Daily Details bottom sheet (day 5 holds the saved fast). Returns True when the sheet is showing.""" nodes = ui() day = find_node(nodes, text="5") marker = find_node(nodes, content_desc="Goal Met") if day and marker and "_center" in day and "_center" in marker: x = (day["_center"][0] + marker["_center"][0]) // 2 y = (day["_center"][1] + marker["_center"][1]) // 2 tap(x, y) elif marker: tap_node(marker) elif day: tap_node(day) else: return False return any("details for" in k.lower() for k in and_showing()) def _tap_enabled_dialog_save(): """Tap 'Save' in an in-place dialog (Add Profile), robustly and WITHOUT dismissing the dialog. 'Save' is a non-clickable TextView whose ENABLED clickable parent must be tapped; that parent is enabled=false until a name is entered. The kit's hide_keyboard() would close this Compose dialog (outside-tap / BACK), so this tolerates the keyboard being up: it re-dumps for fresh (keyboard-shifted) bounds, then taps the SMALLEST enabled clickable View that contains the 'Save' text centre. Returns True only when it tapped an ENABLED Save control.""" d = ui() save = find_node(d, text="Save") if not save or "_center" not in save: return False sx, sy = save["_center"] best = None for n in d: if (n.get("clickable") == "true" and n.get("enabled") == "true" and "_bounds" in n): x1, y1, x2, y2 = n["_bounds"] if x1 <= sx <= x2 and y1 <= sy <= y2: area = (x2 - x1) * (y2 - y1) if best is None or area < best[0]: best = (area, ((x1 + x2) // 2, (y1 + y2) // 2)) if best is None: return False # Save present but its clickable parent disabled tap(*best[1]) settle("tap") return True # ── Named depth helpers (the and_enter_*/and_reach_* NAME backs a depth>=1 claim; # each body is a real, proven jump). ─────────────────────────────────────────── def and_reach_profiles(): """Dashboard -> Manage Profiles. Proven: 'Other Profiles' appears, the goal card 'Set your goal' vanishes. Counts one surface (jump_kind='reach').""" n = find_node(ui(), text="Manage Profiles") or find_node_ci(ui(), "Manage Profiles") if not n: return False return and_reach_surface(n, "Other Profiles", "Set your goal") def and_enter_add_profile_dialog(): """Manage Profiles -> the 'Add Profile' dialog (a new window layer with 3 EditText). Counts one surface (depth+1).""" n = find_node(ui(), content_desc="Add Profile") if not n or not tap_node(n): return False if len(find_by_class(ui(), "EditText")) < 3: return False and_enter("Add Profile dialog") return True def and_reach_daily_details(): """History pane -> Daily Details sheet for day 5. Counts one surface.""" before = and_showing() if not open_daily_details_day5(): return False after = and_showing() ok = and_reach(before, after, "Details for", "August 2026") if ok: and_enter("Daily Details") return ok def and_reach_edit_fast(): """Daily Details sheet -> Edit Fast dialog (pencil). Counts one surface.""" n = find_node(ui(), content_desc="Edit Fast") if not n: return False return and_reach_surface(n, "Start Time", "Details for") def long_press_profile(name_or_duration): """Long-press a profile card body -> the 'Edit | Favourite | Delete' button group. Returns True when the menu appears. SOLE-OWNER long-press.""" n = find_node(ui(), text=name_or_duration) if not n: return False long_press(n, ms=1000) menu = ui() return (find_node(menu, text="Favourite") is not None and find_node(menu, text="Edit") is not None) # ═══════════════════════════════════════════════════════════════════════════════ # (1) CRUD CREATE + PERSISTENCE — the primary create flow, survives process death # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_create_fast_persists", "interaction_create_fast_persists_vlm")) def test_create_fast_survives_process_death(): """Full create -> verify -> persist: start Test Timer, End, rate 4 stars, Save; assert the Dashboard 'Fasts' count went 0 -> 1 and a fast appeared in History; then KILL the process and relaunch and assert the record is STILL there. The negative half (count 0 + empty history before) is what makes it discriminating.""" open_main_clear() absent_before = (_fasts_count() == 0 and find_node_ci(ui(), "No recent fasts to show.") is not None) made = save_test_timer_fast() if not made: record("interaction_create_fast_persists", False, "feature_missing: could not complete+Save a Test Timer fast (no goal " "cell / no summary modal / no Save)", depth=0, jump_kind="value", expect="Dashboard 'Fasts' 0->1 and a History fast after Save+relaunch") # spend the paired VLM record on whatever is on screen vlm_assert("interaction_create_fast_persists", "In the 'Rate your fast' star row of the completion dialog, are " "exactly 4 of the 5 stars filled in (coloured) and the 5th star an " "empty outline? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=0, jump_kind="value") return after_save = ui() created = (_fasts_count(after_save) == 1 and find_node(after_save, text="This Week") is not None) # process-death probe — the highest-value assertion for this lane kill_and_reopen() survived = ui() persisted = (_fasts_count(survived) == 1 and find_node(survived, text="This Week") is not None) ok = absent_before and created and persisted record("interaction_create_fast_persists", bool(ok), "" if ok else ("behavior_wrong: 'Fasts' count / History did not reflect " "the saved fast" if not created else "behavior_wrong: the saved fast did NOT survive process " "death ('Fasts' count reset or History empty after " "relaunch)"), depth=0, jump_kind="value", expect="Dashboard 'Fasts' 0->1 + History 'This Week'; both still present " "after force-stop+relaunch") # VLM (persistence, visual): the History section on the surviving Dashboard shows # the completed fast with its Goal-Reached check. vlm_assert("interaction_create_fast_persists", "After the app was restarted, does the 'History' section near the " "bottom of the dashboard list a completed fast entry (a duration like " "'0h 2m' under a 'This Week' heading with a green check icon) rather " "than an empty 'No recent fasts' message? Answer YES or NO.", RESULTS_DIR, tag="content", depth=0, jump_kind="value") # ═══════════════════════════════════════════════════════════════════════════════ # (2) MULTI-RECORD INTEGRITY — add 3 fasts; the count reflects all 3, survives kill # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_multi_record_integrity", "interaction_multi_record_integrity_vlm")) def test_multi_record_integrity(): """Create THREE Test Timer fasts in a row, reading the Dashboard 'Fasts' count back out after each Save. A recreation that keeps only one row (an in-memory 'latest fast' instead of a real table) fails: the count must climb 0->1->2->3 monotonically, never stall at 1. Then relaunch and assert all 3 still counted.""" open_main_clear() counts = [_fasts_count()] # baseline: expect 0 for _ in range(3): if not save_test_timer_fast(): break counts.append(_fasts_count(ui())) # the count must be a strictly-increasing 0,1,2,3 monotonic = (len(counts) == 4 and all(c is not None for c in counts) and counts == [0, 1, 2, 3]) # persistence of the aggregate across a kill: still 3 kill_and_reopen() persisted = _fasts_count(ui()) == 3 ok = monotonic and persisted record("interaction_multi_record_integrity", bool(ok), "" if ok else ("behavior_wrong: the 'Fasts' count did not climb " f"0->1->2->3 across three saves (saw {counts}) — only one " "record is being kept" if not monotonic else "behavior_wrong: the three-fast total (3) did not " "survive process death"), depth=0, jump_kind="value", expect=f"Dashboard 'Fasts' count 0,1,2,3 across three saves, still 3 " f"after relaunch (observed {counts})") # VLM: after 3 fasts the History section is non-empty; assert a populated list. vlm_assert("interaction_multi_record_integrity", "Does the 'History' section of the dashboard show at least one " "completed fast entry with a duration value and a green check icon " "(i.e. it is NOT the empty 'No recent fasts to show.' state)? " "Answer YES or NO.", RESULTS_DIR, tag="content", depth=0, jump_kind="value") # ═══════════════════════════════════════════════════════════════════════════════ # (3) RATING WRITTEN IN SUMMARY, READ BACK IN TWO SURFACES (data integrity) # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_rating_in_daily_details", "interaction_rating_in_daily_details_vlm")) def test_rating_persists_daily_details(): """The 4-star rating written into the summary modal must read back in the Daily Details sheet. Multi-step: create+rate the fast, open History, open day 5's sheet, and assert the rated fast row is shown. (The exact star FILL is a drawn property -> the paired _vlm; the dump-readable half is that the correct fast row 'Test Timer' appears in the 'Details for ...' sheet.)""" open_main_clear() made = save_test_timer_fast() on_hist = made and open_history_via_link() # depth 1 on_sheet = on_hist and and_reach_daily_details() # depth 2 sheet = ui() if on_sheet else [] # the sheet shows the created record: its goal chip within a 'Details for' sheet row_ok = (on_sheet and find_node(sheet, text="Test Timer") is not None and any("details for" in k.lower() for k in and_showing(sheet))) ok = bool(row_ok) record("interaction_rating_in_daily_details", ok, "" if ok else ("setup_failed: could not build " "create->History->Daily-Details" if not on_sheet else "behavior_wrong: the Daily Details sheet did not show " "the created 'Test Timer' fast row"), depth=2, jump_kind="value", expect="Daily Details for Aug 5 shows the 'Test Timer' fast row (created " "with 4 stars)") # VLM (data integrity, visual): the rating on that row is 4 filled + 1 empty star. vlm_assert("interaction_rating_in_daily_details", "In this daily-details panel, does the fast entry (labelled 'Test " "Timer', duration '0h 2m') show a rating of exactly 4 filled/coloured " "stars followed by 1 empty outline star? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=2, jump_kind="value") @and_test(expects=("interaction_rating_in_edit_fast", "interaction_rating_in_edit_fast_vlm")) def test_rating_persists_edit_fast(): """The SAME 4-star rating must also read back in the Edit Fast dialog (a second surface). Deep multi-step: create+rate, History, Daily Details, Edit Fast; assert the dialog shows the record's Start/End times + a 'Rating' row. Cancel out without editing (never taps the red 'Delete Fast').""" open_main_clear() made = save_test_timer_fast() on_hist = made and open_history_via_link() # depth 1 on_sheet = on_hist and and_reach_daily_details() # depth 2 on_dialog = on_sheet and and_reach_edit_fast() # depth 3 dlg = ui() if on_dialog else [] dialog_ok = (on_dialog and find_node(dlg, text="Rating") is not None and find_node(dlg, text="Start Time") is not None and find_node(dlg, text="End Time") is not None) # VLM WHILE THE DIALOG IS OPEN (before the Cancel that reverses it) vlm_assert("interaction_rating_in_edit_fast", "In this 'Edit Fast' dialog, does the 'Rating' row show exactly 4 " "filled/coloured stars followed by 1 empty outline star? " "Answer YES or NO.", RESULTS_DIR, tag="shape", depth=3, jump_kind="value") # leave the dialog non-destructively (Cancel; NEVER 'Delete Fast') cancel = find_node(ui(), text="Cancel") if cancel and is_safe(cancel): tap_node(cancel) else: and_back() ok = bool(dialog_ok) record("interaction_rating_in_edit_fast", ok, "" if ok else ("setup_failed: could not build " "create->History->Daily-Details->Edit-Fast" if not on_dialog else "behavior_wrong: the Edit Fast dialog did not show the " "record's Start/End Time + Rating rows"), depth=3, jump_kind="value", expect="Edit Fast dialog shows Start Time / End Time / Rating for the " "created 4-star fast") # ═══════════════════════════════════════════════════════════════════════════════ # (4) LONG-PRESS CONTEXT MENU (SOLE OWNER) + the data change it drives # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_longpress_menu", "interaction_longpress_menu_vlm")) def test_longpress_context_menu(): """SOLE-OWNER long-press: long-pressing a profile card reveals an 'Edit | Favourite | Delete' button group that is ABSENT beforehand. Assert the absent->present flip of the menu (the outlined-card highlight is drawn -> the paired _vlm).""" open_main_clear() reached = and_reach_profiles() # depth 1 if not reached: record("interaction_longpress_menu", False, "setup_failed: Manage Profiles not reached", depth=1, jump_kind="transition", expect="long-press adds an 'Edit | Favourite | Delete' button group") vlm_assert("interaction_longpress_menu", "Is exactly one fasting-profile card outlined/highlighted with a " "coloured border distinct from the other cards? Answer YES or NO.", RESULTS_DIR, tag="color", depth=1, jump_kind="transition") return before = ui() menu_absent_before = find_node(before, text="Favourite") is None appeared = long_press_profile("12 Hours") ok = menu_absent_before and appeared record("interaction_longpress_menu", bool(ok), "" if ok else ("feature_missing: long-pressing a profile card did not " "reveal an 'Edit | Favourite | Delete' button group"), depth=1, jump_kind="transition", expect="Long-press: 'Edit'+'Favourite'+'Delete' button group appeared " "(absent before)") # VLM: the long-pressed card gets a coloured outline distinct from the others. vlm_assert("interaction_longpress_menu", "Is exactly one fasting-profile card outlined/highlighted with a " "coloured border that is distinct from the other cards' borders? " "Answer YES or NO.", RESULTS_DIR, tag="color", depth=1, jump_kind="transition") @and_test(expects=("interaction_longpress_set_favourite", "interaction_longpress_set_favourite_vlm")) def test_longpress_set_favourite(): """Long-press -> tap 'Favourite' -> the 'Favourite Fast' section (empty hint beforehand) now holds the chosen profile card. Multi-step data change; assert the hint 'Press and hold a profile...' DISAPPEARS and the profile name appears in the favourite section. Then relaunch and assert the favourite PERSISTS.""" open_main_clear() reached = and_reach_profiles() # depth 1 hint_before = (reached and find_node_ci(ui(), "Press and hold a profile to add it as your " "favourite") is not None) got_menu = reached and long_press_profile("12 Hours") if got_menu: fav = find_node(ui(), text="Favourite") if fav and is_safe(fav): tap_node(fav) settle("tap") after = ui() hint_gone = find_node_ci(after, "Press and hold a profile to add it as your " "favourite") is None # the favourite card now sits ABOVE the 'Other Profiles' heading fav_y = oth_y = None for n in after: if n.get("text", "") == "Favourite Fast" and "_bounds" in n: fav_y = n["_bounds"][3] if n.get("text", "") == "Other Profiles" and "_bounds" in n: oth_y = n["_bounds"][1] card = find_node(after, text="12-Hour Fast") in_fav_section = (card is not None and "_center" in card and fav_y is not None and oth_y is not None and fav_y < card["_center"][1] < oth_y) # persistence: the favourite survives a process kill kill_and_reopen() and_reset_depth() reopened = and_reach_profiles() persisted = (reopened and find_node_ci(ui(), "Press and hold a profile to add it as your " "favourite") is None) ok = bool(hint_before and hint_gone and in_fav_section and persisted) record("interaction_longpress_set_favourite", ok, "" if ok else ("setup_failed: could not reach Manage Profiles / long-press" if not got_menu else "behavior_wrong: 'Favourite' did not move the profile " "into the 'Favourite Fast' section, or it did not " "survive relaunch"), depth=1, jump_kind="value", expect="After long-press->Favourite: hint gone + '12-Hour Fast' in the " "Favourite Fast section; still favourited after relaunch") # VLM: a profile card now occupies the Favourite Fast section. vlm_assert("interaction_longpress_set_favourite", "Under the 'Favourite Fast' heading (above 'Other Profiles'), is there " "now a fasting-profile card, rather than only the grey hint text 'Press " "and hold a profile to add it as your favourite'? Answer YES or NO.", RESULTS_DIR, tag="position", depth=1, jump_kind="value") # ═══════════════════════════════════════════════════════════════════════════════ # (5) CRUD CREATE — a new profile, read back in the grid, survives a fresh open # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_create_profile", "interaction_create_profile_vlm")) def test_create_profile(): """Create a profile via Add Profile -> Save and read the new card back out of a fresh grid. Distinctive marker 'kitprofZ' so the read-back cannot match any seeded profile; asserted ABSENT before and PRESENT after. Then re-open Manage Profiles from scratch and assert it is STILL there (persisted). Note: only the Profile Name is required (Save's clickable parent enables once a name is present); the dialog's Save is tapped DIRECTLY with the keyboard up, because the kit's hide_keyboard() would close this Compose dialog.""" open_main_clear() reached = and_reach_profiles() # depth 1 absent_before = reached and scroll_into_view(MARK, max_swipes=6) is None opened = reached and and_enter_add_profile_dialog() # depth 2 if not opened: record("interaction_create_profile", False, "feature_missing: Add Profile dialog with 3 EditText not reached", depth=2, jump_kind="value", expect=f"profile card {MARK!r} present in Other Profiles after Save") vlm_assert("interaction_create_profile", f"Is there a fasting-profile card labelled '{MARK}' in the profiles " f"grid? Answer YES or NO.", RESULTS_DIR, tag="content", depth=2, jump_kind="value") return # first EditText by y-order is the Profile Name field; typing it enables Save edits = sorted(find_by_class(ui(), "EditText"), key=lambda n: n["_bounds"][1] if "_bounds" in n else 0) # verify_focus=False: this Compose dialog shifts the EditText bounds when # the keyboard animates in, which makes the kit's focus-verify retry # double-tap a stale node and lose the text; a single tap+type is reliable. typed = bool(edits) and type_text(edits[0], MARK, verify_focus=False) # tap the ENABLED Save control directly (keyboard up); do NOT hide_keyboard() saved = _tap_enabled_dialog_save() # read the created card back out of a FRESH, scrolled grid present_after = scroll_into_view(MARK, max_swipes=6) is not None # persistence: re-open Manage Profiles from scratch; the profile is still listed kill_and_reopen() and_reset_depth() reopened = and_reach_profiles() persisted = reopened and scroll_into_view(MARK, max_swipes=6) is not None ok = bool(absent_before and typed and saved and present_after and persisted) record("interaction_create_profile", ok, "" if ok else ("behavior_wrong: profile marker was already present before " "creation" if not absent_before else "behavior_wrong: the created profile " f"{MARK!r} did not appear in the grid / did not survive " "a fresh open"), depth=2, jump_kind="value", expect=f"profile card {MARK!r} absent before, present after Save, still " f"present after relaunch") # re-locate the card so the VLM screenshot frames it scroll_into_view(MARK, max_swipes=4) vlm_assert("interaction_create_profile", f"Is there a fasting-profile card whose title text reads '{MARK}' in " f"the profiles grid? Answer YES or NO.", RESULTS_DIR, tag="content", depth=2, jump_kind="value") # ═══════════════════════════════════════════════════════════════════════════════ # (6) DATA PERSISTENCE ACROSS PROCESS DEATH — an ACTIVE fast survives the kill # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("interaction_active_fast_survives", "interaction_active_fast_survives_vlm")) def test_active_fast_survives_kill(): """Start an Open Fast (∞ — counts up, 'Elapsed Time', never auto-completes), then KILL the process and relaunch: the Dashboard must STILL show the running fast ('Elapsed Time' + 'End Fast'), not the empty goal grid. An in-memory-only recreation shows the goal grid instead. Asserts the goal grid was present before starting (negative half) and gone after.""" open_main_clear() grid_before = find_node(ui(), text="Set your goal") is not None started = _start_goal("Open Fast") active = ui() running_before_kill = (started and find_node(active, text="Elapsed Time") is not None and find_node(active, content_desc="End Fast") is not None) if not running_before_kill: record("interaction_active_fast_survives", False, "feature_missing: could not start an Open Fast ('Elapsed Time' / " "'End Fast' not shown)", depth=0, jump_kind="value", expect="active Open Fast ('Elapsed Time'+'End Fast') persists after " "force-stop+relaunch") vlm_assert("interaction_active_fast_survives", "Is there a circular ring or arc drawn around a large running " "timer near the top-centre of the screen (an active fast in " "progress)? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=0, jump_kind="value") return # process-death probe kill_and_reopen() survived = ui() still_running = (find_node(survived, text="Elapsed Time") is not None and find_node(survived, content_desc="End Fast") is not None and find_node(survived, text="Set your goal") is None) ok = bool(grid_before and still_running) record("interaction_active_fast_survives", ok, "" if ok else "behavior_wrong: the active Open Fast did NOT survive process " "death (Dashboard fell back to the goal grid / lost 'Elapsed " "Time'+'End Fast')", depth=0, jump_kind="value", expect="After force-stop+relaunch: 'Elapsed Time' + 'End Fast' still shown, " "goal grid 'Set your goal' gone") # VLM (persistence, visual): the running-timer ring is still rendered after the kill. vlm_assert("interaction_active_fast_survives", "Is there a circular ring or arc drawn around a large running timer " "near the top-centre of the screen (an active fast still in progress), " "rather than a grid of goal-selection cells? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=0, jump_kind="value") # clean up: end the fast (no save) so a later run starts from a known state ef = find_node(ui(), content_desc="End Fast") if ef: tap_node(ef) settle("tap") and_back() # dismiss the summary, no save # ═══════════════════════════════════════════════════════════════════════════════ TESTS = [ test_create_fast_survives_process_death, test_multi_record_integrity, test_rating_persists_daily_details, test_rating_persists_edit_fast, test_longpress_context_menu, test_longpress_set_favourite, test_create_profile, test_active_fast_survives_kill, ] if __name__ == "__main__": if not device_online(): print("setup_failed: device offline / adb tunnel down — aborting") sys.exit(2) run_suite(TESTS, "interaction")