522 lines
23 KiB
Python
522 lines
23 KiB
Python
import json
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
|
|
MODULE = Path(__file__).parents[1] / "frontend" / "push-notifications.js"
|
|
INDEX = MODULE.parent / "index.html"
|
|
DASHBOARD = MODULE.parent / "dashboard.js"
|
|
|
|
|
|
def run_scenario(script: str) -> dict:
|
|
harness = r"""
|
|
const createPushNotifications = require(__MODULE__);
|
|
const state = { prompts:0, requests:[], subscriptions:[], text:'' };
|
|
const control = {
|
|
checked:false, disabled:false,
|
|
addEventListener:(_name, callback) => state.change = callback,
|
|
};
|
|
const deadlineControl = {
|
|
checked:false, disabled:false,
|
|
addEventListener:(_name, callback) => state.deadlineChange = callback,
|
|
};
|
|
const deadlineHour = {value:'9', disabled:false, addEventListener:(_name, callback) => state.deadlineHourChange = callback};
|
|
const deadlineDays = {value:'2', disabled:false, addEventListener:(_name, callback) => state.deadlineDaysChange = callback};
|
|
const deadlineStatus = {set textContent(value) { state.deadlineText = value; }, get textContent() { return state.deadlineText; }};
|
|
const startDayControl = {
|
|
checked:false, disabled:false,
|
|
addEventListener:(_name, callback) => state.startDayChange = callback,
|
|
};
|
|
const startDayHour = {value:'9', disabled:false};
|
|
const startDayStatus = {set textContent(value) { state.startDayText = value; }, get textContent() { return state.startDayText; }};
|
|
const followingControl = {
|
|
checked:false, disabled:false,
|
|
addEventListener:(_name, callback) => state.followingChange = callback,
|
|
};
|
|
const followingStatus = {set textContent(value) { state.followingText = value; }, get textContent() { return state.followingText; }};
|
|
const humanGateControl = {
|
|
checked:false, disabled:false,
|
|
addEventListener:(_name, callback) => state.humanGateChange = callback,
|
|
};
|
|
const humanGateStatus = {set textContent(value) { state.humanGateText = value; }, get textContent() { return state.humanGateText; }};
|
|
const quietControl = {checked:false, disabled:false, addEventListener:(_name, callback) => state.quietChange = callback};
|
|
const quietStart = {value:'22:00', disabled:false, addEventListener:(_name, callback) => state.quietStartChange = callback};
|
|
const quietEnd = {value:'07:00', disabled:false, addEventListener:(_name, callback) => state.quietEndChange = callback};
|
|
const quietStatus = {set textContent(value) { state.quietText = value; }, get textContent() { return state.quietText; }};
|
|
const status = {set textContent(value) { state.text = value; }, get textContent() { return state.text; }};
|
|
const testControl = {hidden:true, disabled:false, addEventListener:(_name, callback) => state.testDelivery = callback};
|
|
const deadlineSnooze = {hidden:true};
|
|
const deadlineSnoozeStatus = {set textContent(value) { state.snoozeText = value; }, get textContent() { return state.snoozeText; }};
|
|
const deadlineSnoozeReview = {disabled:false, addEventListener:(_name, callback) => state.reviewSnooze = callback};
|
|
const existing = {endpoint:'https://push.example/device', toJSON() { return {endpoint:this.endpoint, keys:{p256dh:'key',auth:'auth'}}; }};
|
|
const registration = {pushManager:{
|
|
getSubscription: async () => state.current || null,
|
|
subscribe: async options => { state.subscriptions.push(options); state.current=existing; return existing; },
|
|
}};
|
|
const feature = createPushNotifications({
|
|
control, status, testControl, deadlineControl, deadlineStatus, deadlineHour, deadlineDays,
|
|
startDayControl, startDayStatus, startDayHour,
|
|
followingControl, followingStatus,
|
|
humanGateControl, humanGateStatus,
|
|
quietControl, quietStart, quietEnd, quietStatus,
|
|
deadlineSnooze, deadlineSnoozeStatus, deadlineSnoozeReview,
|
|
onReviewDeadlines:() => { state.reviewed = true; },
|
|
notification: state.notification = {permission:'default', requestPermission:async () => { state.prompts += 1; state.notification.permission = state.permission || 'granted'; return state.notification.permission; }},
|
|
serviceWorker: {ready:Promise.resolve(registration)},
|
|
fetchJson: async (url, options={}) => { state.requests.push([url,options.method || 'GET',options.body || '']); if (state.failResume && options.method === 'DELETE' && url.endsWith('/deadlines/snooze')) throw new Error('offline'); return state.server || {available:true,subscribed:false,public_key:'AQID'}; },
|
|
});
|
|
(async () => { __SCENARIO__ })().catch(error => { console.error(error); process.exit(1); });
|
|
""".replace("__MODULE__", json.dumps(str(MODULE))).replace("__SCENARIO__", script)
|
|
completed = subprocess.run(
|
|
["node", "-e", harness], capture_output=True, check=True, text=True
|
|
)
|
|
return json.loads(completed.stdout)
|
|
|
|
|
|
def test_initialization_reports_availability_without_prompting_for_permission():
|
|
result = run_scenario("await feature.init(); process.stdout.write(JSON.stringify(state));")
|
|
|
|
assert result["prompts"] == 0
|
|
assert result["requests"] == [["api/v1/push-subscription", "GET", ""]]
|
|
assert result["text"] == "New update notifications are off for this device."
|
|
|
|
|
|
def test_user_gesture_subscribes_device_and_reports_enabled_state():
|
|
result = run_scenario("""
|
|
await feature.init();
|
|
control.checked = true;
|
|
await state.change();
|
|
process.stdout.write(JSON.stringify(state));
|
|
""")
|
|
|
|
assert result["prompts"] == 1
|
|
assert result["subscriptions"][0]["userVisibleOnly"] is True
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription", "PUT"]
|
|
assert json.loads(result["requests"][-1][2])["endpoint"] == "https://push.example/device"
|
|
assert result["text"] == "New update notifications enabled for this device."
|
|
|
|
|
|
def test_following_alert_toggle_is_opt_in_and_does_not_change_other_channels():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,following_enabled:false,deadline_enabled:true,start_day_enabled:true,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
followingControl.checked = true;
|
|
await state.followingChange();
|
|
process.stdout.write(JSON.stringify({requests:state.requests, following:followingControl.checked, deadline:deadlineControl.checked, startDay:startDayControl.checked, text:state.followingText}));
|
|
""")
|
|
|
|
assert result["following"] is True
|
|
assert result["deadline"] is True
|
|
assert result["startDay"] is True
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/following", "PUT"]
|
|
assert json.loads(result["requests"][-1][2]) == {"enabled": True}
|
|
assert result["text"] == "Following change alerts enabled for this device."
|
|
|
|
|
|
def test_device_settings_render_and_wire_the_following_alert_preference():
|
|
index = INDEX.read_text()
|
|
dashboard = DASHBOARD.read_text()
|
|
|
|
assert 'for="push-following"' in index
|
|
assert 'id="push-following" type="checkbox"' in index
|
|
assert 'id="push-following-status" role="status" aria-live="polite"' in index
|
|
assert "followingControl:qs('#push-following')" in dashboard
|
|
assert "followingStatus:qs('#push-following-status')" in dashboard
|
|
|
|
|
|
def test_human_gate_alert_toggle_is_opt_in_and_wired_for_touch_settings():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,human_gates_enabled:false,following_enabled:true,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
humanGateControl.checked = true;
|
|
await state.humanGateChange();
|
|
process.stdout.write(JSON.stringify({requests:state.requests, checked:humanGateControl.checked, following:followingControl.checked, text:state.humanGateText}));
|
|
""")
|
|
|
|
assert result["checked"] is True
|
|
assert result["following"] is True
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/human-gates", "PUT"]
|
|
assert json.loads(result["requests"][-1][2]) == {"enabled": True}
|
|
assert result["text"] == "Human Gate decision alerts enabled for this device."
|
|
|
|
index = INDEX.read_text()
|
|
dashboard = DASHBOARD.read_text()
|
|
assert 'for="push-human-gates"' in index
|
|
assert 'id="push-human-gates" type="checkbox"' in index
|
|
assert 'id="push-human-gates-status" role="status" aria-live="polite"' in index
|
|
assert "humanGateControl:qs('#push-human-gates')" in dashboard
|
|
assert "humanGateStatus:qs('#push-human-gates-status')" in dashboard
|
|
|
|
|
|
def test_quiet_hours_are_restored_and_saved_as_one_local_schedule():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,quiet_hours_enabled:true,quiet_hours_start:'21:30',quiet_hours_end:'06:45',quiet_hours_timezone:'America/New_York',public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
quietStart.value = '22:15';
|
|
quietEnd.value = '07:30';
|
|
await state.quietStartChange();
|
|
process.stdout.write(JSON.stringify({requests:state.requests, checked:quietControl.checked, start:quietStart.value, end:quietEnd.value, text:state.quietText}));
|
|
""")
|
|
|
|
assert result["checked"] is True
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/quiet-hours", "PUT"]
|
|
body = json.loads(result["requests"][-1][2])
|
|
assert body["enabled"] is True
|
|
assert body["start"] == "22:15"
|
|
assert body["end"] == "07:30"
|
|
assert isinstance(body["timezone"], str) and body["timezone"]
|
|
assert result["text"] == "Routine alerts paused from 22:15 to 07:30 local time."
|
|
|
|
|
|
def test_device_settings_render_and_wire_mobile_quiet_hours():
|
|
index = INDEX.read_text()
|
|
dashboard = DASHBOARD.read_text()
|
|
|
|
assert 'id="push-quiet-hours" type="checkbox"' in index
|
|
assert 'id="push-quiet-start" type="time"' in index
|
|
assert 'id="push-quiet-end" type="time"' in index
|
|
assert 'id="push-quiet-status" role="status" aria-live="polite"' in index
|
|
module = MODULE.read_text()
|
|
assert "querySelector('#push-quiet-hours')" in module
|
|
assert "querySelector('#push-quiet-start')" in module
|
|
assert "querySelector('#push-quiet-end')" in module
|
|
|
|
|
|
def test_degraded_device_can_run_a_test_notification_and_show_recovery():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,public_key:'AQID',delivery_health:{unread:{state:'degraded',consecutive_failures:3,reason:'timeout'}}};
|
|
state.current = existing;
|
|
await feature.init();
|
|
const degraded = {text:state.text,hidden:testControl.hidden};
|
|
state.server = {delivery_state:'healthy',delivered:true};
|
|
await state.testDelivery();
|
|
process.stdout.write(JSON.stringify({degraded,text:state.text,hidden:testControl.hidden,disabled:testControl.disabled,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["degraded"] == {
|
|
"text": "Update notifications need attention after 3 failed deliveries. Send a test notification.",
|
|
"hidden": False,
|
|
}
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/test", "POST"]
|
|
assert result["text"] == "Test delivered. Update notifications are working on this device."
|
|
assert result["hidden"] is False
|
|
assert result["disabled"] is False
|
|
|
|
|
|
def test_deadline_opt_in_reuses_subscription_and_sends_local_timezone_without_second_prompt():
|
|
result = run_scenario("""
|
|
state.current = existing;
|
|
state.server = {available:true,subscribed:true,deadline_enabled:false,public_key:'AQID'};
|
|
await feature.init();
|
|
deadlineControl.checked = true;
|
|
await state.deadlineChange();
|
|
process.stdout.write(JSON.stringify(state));
|
|
""")
|
|
|
|
assert result["prompts"] == 0
|
|
assert result["subscriptions"] == []
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/deadlines", "PUT"]
|
|
body = json.loads(result["requests"][-1][2])
|
|
assert body["enabled"] is True
|
|
assert body["reminder_hour"] == 9
|
|
assert isinstance(body["timezone"], str) and body["timezone"]
|
|
assert result["deadlineText"] == "Deadline reminders enabled for 09:00 local time, next 2 days."
|
|
|
|
|
|
def test_start_day_opt_in_reuses_subscription_and_persists_local_hour():
|
|
result = run_scenario("""
|
|
state.current = existing;
|
|
state.server = {available:true,subscribed:true,start_day_enabled:false,start_day_reminder_hour:9,public_key:'AQID'};
|
|
await feature.init();
|
|
startDayHour.value = '8';
|
|
startDayControl.checked = true;
|
|
await state.startDayChange();
|
|
process.stdout.write(JSON.stringify(state));
|
|
""")
|
|
|
|
assert result["prompts"] == 0
|
|
assert result["requests"][-1][0:2] == ["api/v1/push-subscription/start-day", "PUT"]
|
|
body = json.loads(result["requests"][-1][2])
|
|
assert body["enabled"] is True
|
|
assert body["reminder_hour"] == 8
|
|
assert isinstance(body["timezone"], str) and body["timezone"]
|
|
assert result["startDayText"] == "Start-day reminder enabled for 08:00 local time."
|
|
|
|
|
|
def test_deadline_setup_subscribes_once_and_persists_selected_local_hour():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:false,deadline_enabled:false,reminder_hour:9,public_key:'AQID'};
|
|
await feature.init();
|
|
deadlineHour.value = '8';
|
|
await feature.enableDeadline();
|
|
process.stdout.write(JSON.stringify(state));
|
|
""")
|
|
|
|
assert result["prompts"] == 1
|
|
assert len(result["subscriptions"]) == 1
|
|
assert [request[0] for request in result["requests"][-2:]] == [
|
|
"api/v1/push-subscription", "api/v1/push-subscription/deadlines",
|
|
]
|
|
body = json.loads(result["requests"][-1][2])
|
|
assert body["enabled"] is True
|
|
assert body["reminder_hour"] == 8
|
|
assert result["deadlineText"] == "Deadline reminders enabled for 08:00 local time, next 2 days."
|
|
|
|
|
|
def test_deadline_setup_persists_and_restores_confirmed_horizon():
|
|
saved = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,reminder_hour:9,reminder_days:2,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
deadlineDays.value = '7';
|
|
await feature.changeDeadline();
|
|
process.stdout.write(JSON.stringify(state));
|
|
""")
|
|
|
|
assert json.loads(saved["requests"][-1][2])["reminder_days"] == 7
|
|
assert saved["deadlineText"] == "Deadline reminders enabled for 09:00 local time, next 7 days."
|
|
|
|
restored = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,reminder_hour:17,reminder_days:0,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
process.stdout.write(JSON.stringify({days:deadlineDays.value, readiness:feature.deadlineReadiness()}));
|
|
""")
|
|
assert restored == {
|
|
"days": "0",
|
|
"readiness": {
|
|
"state": "complete",
|
|
"detail": "Deadline reminders enabled for 17:00 local time, due today.",
|
|
},
|
|
}
|
|
|
|
|
|
def test_deadline_setup_restores_confirmed_hour_and_denial_stays_incomplete():
|
|
restored = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,reminder_hour:17,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
process.stdout.write(JSON.stringify({hour:deadlineHour.value, checked:deadlineControl.checked, readiness:feature.deadlineReadiness()}));
|
|
""")
|
|
assert restored == {
|
|
"hour": "17", "checked": True,
|
|
"readiness": {"state": "complete", "detail": "Deadline reminders enabled for 17:00 local time, next 2 days."},
|
|
}
|
|
|
|
denied = run_scenario("""
|
|
state.server = {available:true,subscribed:false,deadline_enabled:false,reminder_hour:9,public_key:'AQID'};
|
|
state.permission = 'denied';
|
|
await feature.init();
|
|
deadlineHour.value = '8';
|
|
await feature.enableDeadline();
|
|
process.stdout.write(JSON.stringify({checked:deadlineControl.checked, readiness:feature.deadlineReadiness(), requests:state.requests}));
|
|
""")
|
|
assert denied["checked"] is False
|
|
assert denied["readiness"]["state"] == "blocked"
|
|
assert denied["readiness"]["actionLabel"] == "Check again"
|
|
assert "blocked" in denied["readiness"]["detail"].lower()
|
|
assert [request[0] for request in denied["requests"]] == ["api/v1/push-subscription"]
|
|
|
|
|
|
def test_blocked_update_setup_can_recheck_without_reprompting_or_mutating():
|
|
result = run_scenario("""
|
|
state.permission = 'denied';
|
|
await feature.init();
|
|
control.checked = true;
|
|
await state.change();
|
|
const blocked = feature.notificationReadiness();
|
|
await feature.recoverPermission();
|
|
process.stdout.write(JSON.stringify({blocked,after:feature.notificationReadiness(),prompts:state.prompts,subscriptions:state.subscriptions.length,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["blocked"] == {
|
|
"state": "blocked",
|
|
"detail": "Notifications are blocked. Allow them in browser settings, then check again.",
|
|
"actionLabel": "Check again",
|
|
}
|
|
assert result["after"] == result["blocked"]
|
|
assert result["prompts"] == 1
|
|
assert result["subscriptions"] == 0
|
|
assert result["requests"] == [["api/v1/push-subscription", "GET", ""]]
|
|
|
|
|
|
def test_previously_blocked_permission_starts_a_resumable_update_intent():
|
|
result = run_scenario("""
|
|
state.permission = 'denied';
|
|
state.notification.permission = 'denied';
|
|
await feature.init();
|
|
await feature.recoverPermission('updates');
|
|
state.notification.permission = 'granted';
|
|
const readyToRecover = feature.notificationReadiness();
|
|
await feature.recoverPermission('updates');
|
|
process.stdout.write(JSON.stringify({readyToRecover,readiness:feature.notificationReadiness(),prompts:state.prompts,subscriptions:state.subscriptions.length,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["readyToRecover"]["actionLabel"] == "Check again"
|
|
assert result["readiness"]["state"] == "complete"
|
|
assert result["prompts"] == 0
|
|
assert result["subscriptions"] == 1
|
|
assert [request[0:2] for request in result["requests"]] == [
|
|
["api/v1/push-subscription", "GET"],
|
|
["api/v1/push-subscription", "PUT"],
|
|
]
|
|
|
|
|
|
def test_permission_recovery_resumes_pending_update_subscription_once():
|
|
result = run_scenario("""
|
|
state.permission = 'denied';
|
|
await feature.init();
|
|
control.checked = true;
|
|
await state.change();
|
|
state.notification.permission = 'granted';
|
|
const readyToRecover = feature.notificationReadiness();
|
|
await feature.recoverPermission();
|
|
await feature.recoverPermission();
|
|
process.stdout.write(JSON.stringify({readyToRecover,readiness:feature.notificationReadiness(),prompts:state.prompts,subscriptions:state.subscriptions.length,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["readyToRecover"] == {
|
|
"state": "blocked",
|
|
"detail": "Notification permission changed. Check again to finish setup.",
|
|
"actionLabel": "Check again",
|
|
}
|
|
assert result["readiness"]["state"] == "complete"
|
|
assert result["prompts"] == 1
|
|
assert result["subscriptions"] == 1
|
|
assert [request[0:2] for request in result["requests"]] == [
|
|
["api/v1/push-subscription", "GET"],
|
|
["api/v1/push-subscription", "PUT"],
|
|
]
|
|
|
|
|
|
def test_permission_recovery_resumes_pending_deadline_choices_once():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:false,deadline_enabled:false,reminder_hour:9,reminder_days:2,public_key:'AQID'};
|
|
state.permission = 'denied';
|
|
await feature.init();
|
|
deadlineHour.value = '17';
|
|
deadlineDays.value = '7';
|
|
await feature.enableDeadline();
|
|
const blocked = feature.deadlineReadiness();
|
|
state.notification.permission = 'granted';
|
|
const readyToRecover = feature.deadlineReadiness();
|
|
await feature.recoverPermission();
|
|
await feature.recoverPermission();
|
|
process.stdout.write(JSON.stringify({blocked,readyToRecover,readiness:feature.deadlineReadiness(),prompts:state.prompts,subscriptions:state.subscriptions.length,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["blocked"]["state"] == "blocked"
|
|
assert result["blocked"]["actionLabel"] == "Check again"
|
|
assert result["readyToRecover"] == {
|
|
"state": "blocked",
|
|
"detail": "Notification permission changed. Check again to finish setup.",
|
|
"actionLabel": "Check again",
|
|
}
|
|
assert result["readiness"] == {
|
|
"state": "complete",
|
|
"detail": "Deadline reminders enabled for 17:00 local time, next 7 days.",
|
|
}
|
|
assert result["prompts"] == 1
|
|
assert result["subscriptions"] == 1
|
|
assert [request[0:2] for request in result["requests"]] == [
|
|
["api/v1/push-subscription", "GET"],
|
|
["api/v1/push-subscription", "PUT"],
|
|
["api/v1/push-subscription/deadlines", "PUT"],
|
|
]
|
|
assert json.loads(result["requests"][-1][2])["reminder_hour"] == 17
|
|
assert json.loads(result["requests"][-1][2])["reminder_days"] == 7
|
|
|
|
|
|
def test_active_deadline_snooze_is_visible_in_agenda_with_a_local_resume_time():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,reminder_hour:9,reminder_days:2,snoozed_until:1765003600,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
process.stdout.write(JSON.stringify({hidden:deadlineSnooze.hidden,text:state.snoozeText}));
|
|
""")
|
|
|
|
assert result["hidden"] is False
|
|
assert result["text"].startswith("Deadline reminders snoozed until ")
|
|
|
|
|
|
def test_review_now_resumes_this_device_and_opens_the_deadline_review_flow():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,snoozed_until:1765003600,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
await state.reviewSnooze();
|
|
process.stdout.write(JSON.stringify({hidden:deadlineSnooze.hidden,disabled:deadlineSnoozeReview.disabled,reviewed:state.reviewed,requests:state.requests}));
|
|
""")
|
|
|
|
assert result["requests"][-1][0:2] == [
|
|
"api/v1/push-subscription/deadlines/snooze", "DELETE",
|
|
]
|
|
assert result["hidden"] is True
|
|
assert result["disabled"] is False
|
|
assert result["reviewed"] is True
|
|
|
|
|
|
def test_failed_resume_keeps_the_snooze_visible_and_retryable():
|
|
result = run_scenario("""
|
|
state.server = {available:true,subscribed:true,deadline_enabled:true,snoozed_until:1765003600,public_key:'AQID'};
|
|
state.current = existing;
|
|
await feature.init();
|
|
state.failResume = true;
|
|
await state.reviewSnooze();
|
|
process.stdout.write(JSON.stringify({hidden:deadlineSnooze.hidden,disabled:deadlineSnoozeReview.disabled,text:state.snoozeText,reviewed:state.reviewed}));
|
|
""")
|
|
|
|
assert result == {
|
|
"hidden": False,
|
|
"disabled": False,
|
|
"text": "Could not resume deadline reminders. Check your connection and try again.",
|
|
}
|
|
|
|
|
|
def test_mobile_dashboard_mounts_opt_in_and_precaches_its_controller():
|
|
root = MODULE.parents[1]
|
|
html = (root / "frontend" / "index.html").read_text()
|
|
dashboard = (root / "frontend" / "dashboard.js").read_text()
|
|
worker = (root / "frontend" / "service-worker.js").read_text()
|
|
css = (root / "frontend" / "dashboard.css").read_text()
|
|
requirements = (root / "requirements.txt").read_text()
|
|
readme = (root / "README.md").read_text()
|
|
|
|
assert 'id="push-updates"' in html
|
|
assert 'id="push-update-status"' in html
|
|
assert 'id="push-test"' in html
|
|
assert 'id="push-deadlines"' in html
|
|
assert 'id="push-deadline-hour"' in html
|
|
assert 'id="push-deadline-days"' in html
|
|
assert 'id="device-setup-deadline-days"' in html
|
|
assert 'id="push-deadline-status"' in html
|
|
assert '<script src="static/push-notifications.js"></script>' in html
|
|
assert "createPushNotifications({" in dashboard
|
|
assert "testControl:qs('#push-test')" in dashboard
|
|
assert "BASE + 'static/push-notifications.js'" in worker
|
|
assert ".push-update-control" in css and "min-height:44px" in css
|
|
assert "pywebpush==" in requirements
|
|
assert "STACKCHAIN_VAPID_PUBLIC_KEY" in readme
|
|
assert "STACKCHAIN_VAPID_PRIVATE_KEY" in readme
|
|
|
|
|
|
def test_mobile_agenda_mounts_a_touch_safe_snooze_recovery_flow():
|
|
root = MODULE.parents[1]
|
|
html = (root / "frontend" / "index.html").read_text()
|
|
dashboard = (root / "frontend" / "dashboard.js").read_text()
|
|
css = (root / "frontend" / "dashboard.css").read_text()
|
|
|
|
assert 'id="deadline-snooze"' in html
|
|
assert 'id="deadline-snooze-status"' in html
|
|
assert 'id="review-snoozed-deadlines"' in html
|
|
assert "deadlineSnooze:qs('#deadline-snooze')" in dashboard
|
|
assert "onReviewDeadlines:" in dashboard
|
|
assert "window.location.hash = '#/my-work/agenda'" in dashboard
|
|
assert "qs('#protect-today')" in dashboard
|
|
assert ".deadline-snooze" in css
|
|
assert ".deadline-snooze button { min-height:44px;" in css
|
|
assert "overflow-wrap:anywhere" in css
|