diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt index ed7cec22..617a5310 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt @@ -54,7 +54,8 @@ class FaceclawCalendarProvider private constructor() { * boundaries the provider stores them as. */ @JvmStatic - fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long): String { + @JvmOverloads + fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long, selectedCalendarIdsJson: String = "null"): String { if (context == null || maxEvents <= 0) { return "[]" } @@ -73,11 +74,21 @@ class FaceclawCalendarProvider private constructor() { val events = ArrayList() var cursor: Cursor? = null try { + // Filter instances before the cutoff/limit so excluded calendars + // cannot crowd out selected calendars, including recurrences. + val ids = if (selectedCalendarIdsJson == "null") null else JSONArray(selectedCalendarIdsJson) + if (ids != null && ids.length() == 0) return "[]" + val args = ids?.let { values -> Array(values.length()) { index -> + values.getString(index).also { require(it.matches(Regex("[0-9]+"))) } + } } + val selection = args?.let { + CalendarContract.Instances.CALENDAR_ID + " IN (" + it.joinToString(",") { "?" } + ")" + } cursor = context.contentResolver.query( uri, PROJECTION, - null, - null, + selection, + args, CalendarContract.Instances.BEGIN + " ASC") if (cursor != null) { val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC")) @@ -118,6 +129,33 @@ class FaceclawCalendarProvider private constructor() { return out.toString() } + @JvmStatic + fun getCalendarsJson(context: Context?): String { + if (context == null) return "[]" + val out = JSONArray() + try { + context.contentResolver.query( + CalendarContract.Calendars.CONTENT_URI, + arrayOf(CalendarContract.Calendars._ID, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, + CalendarContract.Calendars.ACCOUNT_NAME, CalendarContract.Calendars.ACCOUNT_TYPE), + null, null, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC", + )?.use { cursor -> + while (cursor.moveToNext()) { + out.put(JSONObject().apply { + put("id", cursor.getLong(0).toString()) + put("name", cursor.getString(1) ?: "") + put("accountName", cursor.getString(2) ?: "") + put("accountType", cursor.getString(3) ?: "") + }) + } + } + } catch (t: Throwable) { + Log.w(TAG, "failed to read calendars", t) + return "[]" + } + return out.toString() + } + private fun readEvent(cursor: Cursor, utc: Calendar, local: Calendar): Event { val allDay = cursor.getInt(4) != 0 var startMs = cursor.getLong(2) diff --git a/app/apps/calendar/calendar-app.ts b/app/apps/calendar/calendar-app.ts index 39caf6ff..42808e4d 100644 --- a/app/apps/calendar/calendar-app.ts +++ b/app/apps/calendar/calendar-app.ts @@ -3,6 +3,7 @@ import { invalidateCalendarCache, onCalendarChanged } from "../../native/calenda import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer"; import { CalendarLayer } from "./calendar"; import { renderCalendarDateIcon } from "./calendar-icon"; +import { calendarSelectionMenuItems } from "./calendar-filter"; import { createInProcessWindow, YieldAtRootLayer, @@ -44,6 +45,10 @@ export function createCalendarAppWindow(options: InProcessAppOptions): InProcess icon: "calendar", drawIcon: makeImageWindowIcon(renderCalendarDateIcon, windowIcon("calendar", "Ca")), closeable: true, + menuItems: () => calendarSelectionMenuItems().map(item => ({ ...item, onSelect: (ctx, menu) => { + ctx.stack.pop(); + return item.onSelect(ctx, menu); + } })), actions: options.actions, baseLayer: new YieldAtRootLayer(new CalendarLayer(requestPermission)), submitFrame: options.submitFrame, diff --git a/app/apps/calendar/calendar-filter.ts b/app/apps/calendar/calendar-filter.ts new file mode 100644 index 00000000..84194664 --- /dev/null +++ b/app/apps/calendar/calendar-filter.ts @@ -0,0 +1,94 @@ +import { getDefaultSmallFont } from "../../graphics/ui-fonts"; +import { type GrayImage } from "../../graphics/image"; +import { truncateText } from "../../graphics/textwrap"; +import { readCalendarSelection, setCalendarSelection } from "../../native/calendar-selection"; +import { readAvailableCalendars } from "../../native/calendar-sources"; +import { hasCalendarPermission } from "../../native/calendar-permissions"; +import { type InputEvent } from "../../ui/gestures"; +import { type Layer, type LayerContext, type PaintBelow } from "../../ui/layers"; +import { drawToggleMenuItem, MenuLayer, type MenuItem } from "../../ui/menu"; + +/** Shared preference for every Android calendar reader. */ +export class CalendarFilterLayer implements Layer { + private menu: MenuLayer | null = null; + private width = 0; + private keys: string[] = []; + + private currentMenu(ctx: LayerContext): MenuLayer { + const calendars = readAvailableCalendars().sort((a, b) => + a.name.localeCompare(b.name) || a.accountName.localeCompare(b.accountName) || a.id.localeCompare(b.id)); + const selection = readCalendarSelection(); + const known = new Set(calendars.map(calendar => calendar.id)); + const keys = ["all", "none"]; + const toggle = (id: string) => { + // Leaving all mode snapshots the current calendars. Newly added calendars + // then stay excluded until selected individually or all mode is restored. + const ids = new Set(readCalendarSelection() ?? calendars.map(calendar => calendar.id)); + if (ids.has(id)) ids.delete(id); else ids.add(id); + setCalendarSelection(Array.from(ids)); + }; + const items: MenuItem[] = [{ + label: "All calendars", + description: "Include all calendars, including calendars added later.", + onSelect: () => setCalendarSelection(null), + render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width, + "All calendars", readCalendarSelection() === null, selected), + }, { + label: "No calendars", + onSelect: () => setCalendarSelection([]), + render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width, + "No calendars", readCalendarSelection()?.length === 0, selected), + }]; + const rows = [ + ...calendars.map(calendar => ({ id: calendar.id, + label: `${calendar.name || "(unnamed)"} / ${calendar.accountName || "Local"} (${calendar.accountType || "local"}) #${calendar.id}` })), + ...(selection ?? []).filter(id => !known.has(id)).map(id => ({ id, label: `Unavailable calendar #${id}` })), + ]; + for (const row of rows) { + keys.push(`calendar:${row.id}`); + items.push({ + label: row.label, + description: row.label, + onSelect: () => toggle(row.id), + render: ({ image, x, y, width, selected }) => { + const font = getDefaultSmallFont(); + const ids = readCalendarSelection(); + drawToggleMenuItem(image, font, x, y, width, truncateText(font, row.label, width - 48), + ids === null || ids.includes(row.id), selected); + }, + }); + } + if (!calendars.length) items.push({ + label: hasCalendarPermission() ? "No calendars available" : "Grant calendar permission on your phone", + disabled: true, onSelect: () => {}, + }); + const key = this.menu?.selectedIndex != null ? this.keys[this.menu.selectedIndex] : "all"; + const index = Math.max(0, keys.indexOf(key ?? "all")); + this.keys = keys; + const width = ctx.stack.getBaseSize().width; + if (!this.menu || this.width !== width) { + this.width = width; + this.menu = new MenuLayer("Calendars displayed", items, { + x: 8, y: 8, width: width - 16, opaque: true, showBorder: false, + footer: "Shared by Calendar and Glanceboard", + }).selectItem(index); + } else this.menu.setItems(items, index); + return this.menu; + } + + paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage { + return this.currentMenu(ctx).paint(ctx, paintBelow); + } + + async handleInput(event: InputEvent, ctx: LayerContext): Promise { + await this.currentMenu(ctx).handleInput(event, ctx); + } +} + +export function calendarSelectionMenuItems(): MenuItem[] { + return global.isAndroid ? [{ + label: "Calendars displayed", + description: "Choose the calendars used by Calendar, Glanceboard and other calendar views.", + onSelect: ctx => ctx.stack.push(new CalendarFilterLayer()), + }] : []; +} diff --git a/app/apps/glanceboard/widgets/index.ts b/app/apps/glanceboard/widgets/index.ts index b07f7b7c..8819f11e 100644 --- a/app/apps/glanceboard/widgets/index.ts +++ b/app/apps/glanceboard/widgets/index.ts @@ -1,5 +1,6 @@ import { type GlanceWidgetDefinition, type GlanceWidgetId } from "../widget"; import { CalendarWidget } from "./calendar-widget"; +import { calendarSelectionMenuItems } from "../../calendar/calendar-filter"; import { CompassWidget } from "./compass-widget"; import { MusicWidget, musicSettingsMenuItems } from "./music-widget"; import { NightscoutWidget } from "./nightscout-widget"; @@ -11,7 +12,7 @@ import { HealthWidget } from "./health-widget"; /** Every widget a board slot can hold. */ export const GLANCE_WIDGETS: readonly GlanceWidgetDefinition[] = [ { id: "system-card", label: "System card", settingsMenuItems: systemCardSettingsMenuItems, create: () => new SystemCardWidget() }, - { id: "calendar", label: "Calendar", tall: true, create: () => new CalendarWidget() }, + { id: "calendar", label: "Calendar", tall: true, settingsMenuItems: calendarSelectionMenuItems, create: () => new CalendarWidget() }, { id: "terminal", label: "Terminal", tall: true, create: () => new TerminalWidget() }, { id: "t3code", label: "T3 Code", tall: true, create: () => new T3CodeWidget() }, { id: "nightscout", label: "Nightscout", create: () => new NightscoutWidget() }, diff --git a/app/native/calendar-selection.ts b/app/native/calendar-selection.ts new file mode 100644 index 00000000..6635b7e5 --- /dev/null +++ b/app/native/calendar-selection.ts @@ -0,0 +1,19 @@ +import { getStringSetting, setStringSetting } from "./settings-store"; + +export const CALENDAR_SELECTION_KEY = "calendar.selectedIds"; +/** null means all calendars (including future ones); [] explicitly means none. */ +export function readCalendarSelection(): string[] | null { + try { + const value = JSON.parse(getStringSetting(CALENDAR_SELECTION_KEY, "null")); + if (value === null) return null; + if (!Array.isArray(value) || !value.every(id => typeof id === "string" && /^\d+$/.test(id))) return null; + return Array.from(new Set(value)); + } catch { + return null; + } +} + +export function setCalendarSelection(ids: readonly string[] | null): void { + if (ids !== null && !ids.every(id => /^\d+$/.test(id))) throw new Error("Invalid calendar ID"); + setStringSetting(CALENDAR_SELECTION_KEY, JSON.stringify(ids === null ? null : Array.from(new Set(ids)))); +} diff --git a/app/native/calendar-sources.ts b/app/native/calendar-sources.ts new file mode 100644 index 00000000..c90b45bb --- /dev/null +++ b/app/native/calendar-sources.ts @@ -0,0 +1,22 @@ +import { Utils } from "@nativescript/core"; +import { hasCalendarPermission } from "./calendar-permissions"; + +declare const com: any; + +export type CalendarSource = { id: string; name: string; accountName: string; accountType: string }; + +/** Android calendar IDs survive renames and distinguish equal display names. */ +export function readAvailableCalendars(): CalendarSource[] { + if (!global.isAndroid || !hasCalendarPermission()) return []; + try { + const context = Utils.android.getApplicationContext(); + if (!context) return []; + const parsed = JSON.parse(String(com.faceclaw.app.FaceclawCalendarProvider.getCalendarsJson(context))); + if (!Array.isArray(parsed)) return []; + return parsed.filter(row => row && typeof row.id === "string" && /^\d+$/.test(row.id)) + .map(row => ({ id: row.id, name: String(row.name ?? ""), + accountName: String(row.accountName ?? ""), accountType: String(row.accountType ?? "") })); + } catch { + return []; + } +} diff --git a/app/native/calendar.ts b/app/native/calendar.ts index 8768947b..0c2abc7b 100644 --- a/app/native/calendar.ts +++ b/app/native/calendar.ts @@ -2,6 +2,8 @@ import { Utils } from "@nativescript/core"; import { hasCalendarPermission } from "../g2/android-permissions"; import { spanCurrent } from "./frame-timings"; import { type CalendarEvent, type CalendarReadState } from "./calendar-types"; +import { CALENDAR_SELECTION_KEY, readCalendarSelection } from "./calendar-selection"; +import { onSettingsStoreChanged } from "./settings-store"; export type { CalendarEvent } from "./calendar-types"; declare const com: any; @@ -13,14 +15,21 @@ declare const com: any; */ // Android reads synchronously; iOS notifies subscribers after background reads. -export function onCalendarChanged(_listener: () => void): () => void { return () => {}; } +export function onCalendarChanged(listener: () => void): () => void { + return onSettingsStoreChanged(key => { + if (key === CALENDAR_SELECTION_KEY || key == null) { + invalidateCalendarCache(); + listener(); + } + }); +} export function getCalendarReadState(): CalendarReadState { return "ready"; } const DEFAULT_MAX_EVENTS = 50; const DEFAULT_WINDOW_MS = 14 * 24 * 60 * 60 * 1000; const CACHE_MS = 30_000; -let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number } | null = null; +let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number; selection: string } | null = null; /** * Upcoming events from now through the given window, ordered by start time. @@ -35,9 +44,11 @@ export function readUpcomingEvents( if (!global.isAndroid || !hasCalendarPermission()) return []; const now = Date.now(); + const selection = JSON.stringify(readCalendarSelection()); if ( !forceRefresh && cache && + cache.selection === selection && cache.maxEvents === maxEvents && cache.windowMs === windowMs && now - cache.atMs < CACHE_MS @@ -55,6 +66,7 @@ export function readUpcomingEvents( context, Math.max(0, Math.round(maxEvents)), Math.max(0, Math.round(windowMs)), + selection, ), ), ); @@ -62,7 +74,7 @@ export function readUpcomingEvents( const events = Array.isArray(parsed) ? parsed.map(normalizeEvent).filter((event): event is CalendarEvent => Boolean(event)) : []; - cache = { events, atMs: now, maxEvents, windowMs }; + cache = { events, atMs: now, maxEvents, windowMs, selection }; return events; } catch { return []; diff --git a/docs/validation-calendars.md b/docs/validation-calendars.md new file mode 100644 index 00000000..3cbf4a71 --- /dev/null +++ b/docs/validation-calendars.md @@ -0,0 +1,29 @@ +# Android calendar selection validation + +Software: `npm test` and `bash lint.sh` for changed TypeScript files. +`tests/calendar-selection.test.cjs` covers preference reloads, all versus none, +duplicate names/accounts, selection changes with cached readers, deleted IDs, +recurrence occurrences and forwarding the selection to the provider before its +limit. Provider SQL structure is checked statically; the mocked bridge does not +replace an Android CalendarContract integration test. + +On an Android device (pending): + +1. With no saved preference, compare events with the current release. +2. Open Calendar's window menu > Calendars displayed (also available through + Glanceboard's Calendar widget settings). Select between two equal-named + calendars belonging to different accounts. Check ID/account labels. +3. Create more than 50 early events in an excluded calendar and later recurring + events in a selected calendar. Check those later occurrences still appear. +4. Select “No calendars”: Calendar, Glanceboard and any other readers must be + empty immediately. Restart and confirm the selection persists. +5. Select individual calendars, rename one, then delete one. Remaining selections + must stay unchanged. A missing selected ID is shown as unavailable and may be + removed; it never causes a fallback to all calendars. +6. Select “All calendars”, add a calendar, and check it is included. In individual + mode, newly added calendars stay excluded. Check all-day and timed recurring + events in both Calendar and Glanceboard, including timezone/DST boundaries. + +IDs are Android CalendarContract IDs, stable across display-name changes within +an installation. Removing/re-adding an account can create new calendar IDs. +The iOS calendar reader and its behavior are unchanged; iOS selection is deferred. diff --git a/tests/calendar-selection.test.cjs b/tests/calendar-selection.test.cjs new file mode 100644 index 00000000..31e559a1 --- /dev/null +++ b/tests/calendar-selection.test.cjs @@ -0,0 +1,150 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); +const ts = require('typescript'); +const source = file => fs.readFileSync(path.join(__dirname, '..', file), 'utf8'); +function load(file, modules, globals = {}) { + const context = { exports: {}, require: name => { + assert.ok(name in modules, `Unexpected import ${name}`); + return modules[name]; + }, ...globals }; + vm.runInNewContext(ts.transpileModule(source(file), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText, context); + return context.exports; +} +function fixture(settings = new Map()) { + const listeners = new Set(); + const storage = { + getStringSetting: (key, fallback) => settings.get(key) ?? fallback, + setStringSetting: (key, value) => { settings.set(key, value); for (const fn of listeners) fn(key); }, + onSettingsStoreChanged: fn => { listeners.add(fn); return () => listeners.delete(fn); }, + }; + const prefs = load('app/native/calendar-selection.ts', { './settings-store': storage }); + let permitted = true; + const calls = []; + const calendars = [ + { id: '1', name: 'Work', accountName: 'one@example.com', accountType: 'google' }, + { id: '2', name: 'Work', accountName: 'two@example.com', accountType: 'google' }, + ]; + const events = [ + { id: 1, calendarId: '1', startMs: 10000, endMs: 20000, title: 'Excluded early' }, + { id: 9, calendarId: '2', startMs: 30000, endMs: 40000, title: 'Recurrence one' }, + { id: 9, calendarId: '2', startMs: 50000, endMs: 60000, title: 'Recurrence two' }, + ]; + const modules = { + '@nativescript/core': { Utils: { android: { getApplicationContext: () => ({}) } } }, + '../g2/android-permissions': { hasCalendarPermission: () => permitted }, + './calendar-permissions': { hasCalendarPermission: () => permitted }, + './frame-timings': { spanCurrent: (_name, fn) => fn() }, + './calendar-selection': prefs, + './settings-store': storage, + }; + const globals = { global: { isAndroid: true }, com: { faceclaw: { app: { FaceclawCalendarProvider: { + getCalendarsJson: () => JSON.stringify(calendars), + getUpcomingEventsJson: (_ctx, max, window, selection) => { + calls.push({ max, window, selection }); + const ids = JSON.parse(selection); + return JSON.stringify(events.filter(event => ids === null || ids.includes(event.calendarId)).slice(0, max)); + }, + } } } } }; + const api = load('app/native/calendar.ts', modules, globals); + const sources = load('app/native/calendar-sources.ts', modules, globals); + return { api, prefs, sources, modules, globals, settings, calls, calendars, + permissions: value => { permitted = value; } }; +} + +test('calendar selection distinguishes all and none, survives restart and rejects invalid data', () => { + const f = fixture(); + assert.equal(f.prefs.readCalendarSelection(), null); + f.prefs.setCalendarSelection([]); + assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), []); + f.prefs.setCalendarSelection(['2', '2', '1']); + assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), ['2', '1']); + f.prefs.setCalendarSelection(null); + assert.equal(fixture(f.settings).prefs.readCalendarSelection(), null); + assert.throws(() => f.prefs.setCalendarSelection(['1 OR 1=1'])); + for (const value of ['oops', '{}', '[false]', '["bad"]']) { + f.settings.set(f.prefs.CALENDAR_SELECTION_KEY, value); + assert.equal(f.prefs.readCalendarSelection(), null); + } +}); + +test('shared reader forwards IDs before limiting, preserves recurrence occurrences and invalidates all cached query variants', async () => { + const f = fixture(); + assert.equal(f.api.readUpcomingEvents(1)[0].title, 'Excluded early'); + f.api.readUpcomingEvents(1); + assert.equal(f.calls.length, 1); + let notifications = 0; + const off = f.api.onCalendarChanged(() => notifications++); + f.prefs.setCalendarSelection(['2']); + const rows = f.api.readUpcomingEvents(2); + assert.deepEqual(Array.from(rows, event => event.id), [9, 9]); + assert.equal(f.calls.at(-1).selection, '["2"]'); + assert.equal(notifications, 1); + assert.equal((await f.api.readUpcomingEventsAsync(1))[0].title, 'Recurrence one'); + off(); + f.prefs.setCalendarSelection([]); + assert.equal(notifications, 1); + assert.equal(f.api.readUpcomingEvents(1).length, 0, 'selection cache key works even without subscriptions'); + assert.equal(fixture(f.settings).api.readUpcomingEvents().length, 0); + f.prefs.setCalendarSelection(['999']); + assert.equal(f.api.readUpcomingEvents().length, 0, 'deleted calendar does not revert to all'); + f.permissions(false); + assert.equal(f.api.readUpcomingEvents().length, 0); + assert.equal(f.sources.readAvailableCalendars().length, 0); +}); + +test('calendar menu distinguishes equal names by account and ID; all, none, deleted and individual selections share preferences', () => { + const f = fixture(); + const { CalendarFilterLayer } = load('app/apps/calendar/calendar-filter.ts', { + '../../graphics/ui-fonts': { getDefaultSmallFont: () => ({}) }, + '../../graphics/textwrap': { truncateText: (_font, text) => text }, + '../../native/calendar-selection': f.prefs, + '../../native/calendar-sources': f.sources, + '../../native/calendar-permissions': { hasCalendarPermission: () => true }, + '../../ui/menu': { + drawToggleMenuItem: () => {}, + MenuLayer: class { + constructor(_title, items) { this.items = items; this.selectedIndex = 0; } + selectItem(index) { this.selectedIndex = index; return this; } + setItems(items, index) { this.items = items; this.selectedIndex = index; } + paint() { return this.items; } + }, + }, + }, f.globals); + const layer = new CalendarFilterLayer(); + const ctx = { stack: { getBaseSize: () => ({ width: 576 }) } }; + const rows = () => layer.paint(ctx, () => {}); + assert.ok(rows()[2].label.includes('one@example.com')); + assert.ok(rows()[3].label.includes('two@example.com')); + rows()[2].onSelect(); + assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']); + rows()[1].onSelect(); + assert.equal(f.api.readUpcomingEvents().length, 0); + rows()[3].onSelect(); + assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']); + f.calendars.pop(); + const missing = rows().find(row => row.label === 'Unavailable calendar #2'); + assert.ok(missing); + missing.onSelect(); + assert.equal(f.prefs.readCalendarSelection().length, 0); + rows()[0].onSelect(); + assert.equal(f.prefs.readCalendarSelection(), null); +}); + +test('Android provider restricts Instances with bound calendar IDs before cutoff and limit', () => { + const kotlin = source('App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt'); + assert.match(kotlin, /Instances\.CALENDAR_ID/); + assert.match(kotlin, /if \(ids != null && ids.length\(\) == 0\) return "\[\]"/); + assert.match(kotlin, /PROJECTION,\s+selection,\s+args,/); + assert.ok(kotlin.indexOf('selection,\n args,') < kotlin.indexOf('events.take(limit)')); + assert.match(kotlin, /CalendarContract\.Calendars\._ID/); + assert.match(kotlin, /CalendarContract\.Calendars\.ACCOUNT_NAME/); + for (const file of ['app/apps/calendar/calendar.ts', 'app/apps/glanceboard/widgets/calendar-widget.ts']) { + assert.match(source(file), /readUpcomingEvents/); + assert.match(source(file), /native\/calendar"/); + } +}); diff --git a/tests/ios-calendar.test.cjs b/tests/ios-calendar.test.cjs index b85b0554..f3f84203 100644 --- a/tests/ios-calendar.test.cjs +++ b/tests/ios-calendar.test.cjs @@ -199,6 +199,7 @@ test('Calendar window subscribes, refreshes periodically, and cleans up on close '../../native/calendar': { onCalendarChanged: fn => { listener = fn; return () => unsubscribed++; } }, '../../ui/shell/chrome-layer': { makeImageWindowIcon() {}, windowIcon() {} }, './calendar': { CalendarLayer: class {} }, './calendar-icon': {}, + './calendar-filter': { calendarSelectionMenuItems: () => [] }, '../../ui/shell/in-process-window': { YieldAtRootLayer: class {}, createInProcessWindow: value => { options = value; return app; } }, }, { setInterval: fn => { tick = fn; return 1; }, clearInterval: () => cleared++ }); createCalendarAppWindow({ onClosed: () => closed++ });