1import { describe, expect, it, beforeEach, vi } from "vitest";2import type { PairedDevice } from "../shared/sync-types";3import { upsertPairedDevice, findPairedDeviceById } from "./paired-devices";4import {5 triggerSyncIfReachable,6 setSyncRunner,7 _resetSyncTriggerForTest,8 getSyncState,9 hydratePersistedSyncState,10} from "./sync-trigger";1112function makeStorageStub() {13 const sync = new Map<string, unknown>();14 const local = new Map<string, unknown>();15 function area(store: Map<string, unknown>) {16 return {17 async get(key?: string | string[] | null) {18 if (key === null || key === undefined) {19 const all: Record<string, unknown> = {};20 for (const [k, v] of store) all[k] = v;21 return all;22 }23 const keys = Array.isArray(key) ? key : [key];24 const out: Record<string, unknown> = {};25 for (const k of keys) if (store.has(k)) out[k] = store.get(k);26 return out;27 },28 async set(values: Record<string, unknown>) {29 for (const [k, v] of Object.entries(values)) store.set(k, v);30 },31 async remove(key: string | string[]) {32 const keys = Array.isArray(key) ? key : [key];33 for (const k of keys) store.delete(k);34 },35 };36 }37 (globalThis as unknown as { chrome: unknown }).chrome = {38 storage: { sync: area(sync), local: area(local) },39 runtime: { sendMessage: () => Promise.resolve() },40 };41}4243const ANDROID: PairedDevice = {44 deviceId: "AAA-android",45 deviceName: "Pixel",46 deviceType: "android",47 longTermPublicKeyHex: "a".repeat(64),48 trustSource: "direct",49 pairedAt: 1700000000000,50};5152const IOS: PairedDevice = {53 deviceId: "BBB-ios",54 deviceName: "iPhone",55 deviceType: "ios",56 longTermPublicKeyHex: "b".repeat(64),57 trustSource: "direct",58 pairedAt: 1700000000000,59};6061const EXT: PairedDevice = {62 deviceId: "CCC-ext",63 deviceName: "Other Chrome",64 deviceType: "extension",65 longTermPublicKeyHex: "c".repeat(64),66 pairedAt: 1700000000000,67};6869describe("triggerSyncIfReachable", () => {70 beforeEach(() => {71 makeStorageStub();72 _resetSyncTriggerForTest();73 });7475 it("does not call the runner when no mobile hosts are paired", async () => {76 await upsertPairedDevice(EXT);77 const runner = vi.fn(async () => ({ ok: true as const, entriesReceived: 0, entriesSent: 0 }));78 setSyncRunner(runner);79 await triggerSyncIfReachable({ reason: "manual" });80 expect(runner).not.toHaveBeenCalled();81 });8283 it("calls the runner once per mobile host on a single trigger", async () => {84 await upsertPairedDevice(ANDROID);85 await upsertPairedDevice(IOS);86 await upsertPairedDevice(EXT);87 const seen: string[] = [];88 setSyncRunner(async (device) => {89 seen.push(device.deviceId);90 return { ok: true, entriesReceived: 1, entriesSent: 0 };91 });92 await triggerSyncIfReachable({ reason: "manual" });93 expect(seen.sort()).toEqual([ANDROID.deviceId, IOS.deviceId]);94 });9596 it("marks lastSyncedAt on each host that completes successfully", async () => {97 await upsertPairedDevice(ANDROID);98 await upsertPairedDevice(IOS);99 setSyncRunner(async () => ({ ok: true, entriesReceived: 0, entriesSent: 0 }));100 await triggerSyncIfReachable({ reason: "manual" });101 const a = await findPairedDeviceById(ANDROID.deviceId);102 const b = await findPairedDeviceById(IOS.deviceId);103 expect(typeof a?.lastSyncedAt).toBe("number");104 expect(typeof b?.lastSyncedAt).toBe("number");105 });106107 it("does not start a second sync if one is already in flight (non-force)", async () => {108 await upsertPairedDevice(ANDROID);109 const runner = vi.fn(async () => {110 await new Promise<void>((r) => setTimeout(r, 50));111 return { ok: true as const, entriesReceived: 0, entriesSent: 0 };112 });113 setSyncRunner(runner);114 const a = triggerSyncIfReachable({ reason: "vault_change" });115 const b = triggerSyncIfReachable({ reason: "vault_change" });116 await Promise.all([a, b]);117 expect(runner).toHaveBeenCalledTimes(1);118 });119120 it("force:true bypasses the syncInFlight guard for manual triggers", async () => {121 await upsertPairedDevice(ANDROID);122 const runner = vi.fn(async () => {123 await new Promise<void>((r) => setTimeout(r, 30));124 return { ok: true as const, entriesReceived: 0, entriesSent: 0 };125 });126 setSyncRunner(runner);127 const a = triggerSyncIfReachable({ reason: "vault_change" });128 const b = triggerSyncIfReachable({ reason: "manual", force: true });129 await Promise.all([a, b]);130 expect(runner).toHaveBeenCalledTimes(2);131 });132133 it("transitions to error state when no host succeeds", async () => {134 await upsertPairedDevice(ANDROID);135 setSyncRunner(async () => {136 throw new Error("unreachable");137 });138 await triggerSyncIfReachable({ reason: "manual" });139 expect(getSyncState().status).toBe("error");140 expect(getSyncState().error).toBe("unreachable");141 });142143 it("returns to idle state on success with aggregated entry counts", async () => {144 await upsertPairedDevice(ANDROID);145 await upsertPairedDevice(IOS);146 setSyncRunner(async () => ({ ok: true, entriesReceived: 3, entriesSent: 2 }));147 await triggerSyncIfReachable({ reason: "manual" });148 const s = getSyncState();149 expect(s.status).toBe("idle");150 expect(s.entriesReceived).toBe(6);151 expect(s.entriesSent).toBe(4);152 expect(typeof s.lastSyncAt).toBe("number");153 });154155 it("syncInFlight is cleared in finally even when runner throws", async () => {156 await upsertPairedDevice(ANDROID);157 setSyncRunner(async () => { throw new Error("runner exploded"); });158 await triggerSyncIfReachable({ reason: "manual", force: true });159 160 let ran = false;161 setSyncRunner(async () => { ran = true; return { ok: true as const, entriesReceived: 0, entriesSent: 0 }; });162 await triggerSyncIfReachable({ reason: "vault_change" });163 expect(ran).toBe(true);164 });165166 it("does not call runner when only vouched devices are in registry", async () => {167 const vouched: PairedDevice = {168 ...ANDROID,169 deviceId: "VVV-vouched",170 trustSource: "vouched",171 };172 await upsertPairedDevice(vouched);173 let ran = false;174 setSyncRunner(async () => { ran = true; return { ok: true as const, entriesReceived: 0, entriesSent: 0 }; });175 await triggerSyncIfReachable({ reason: "foreground" });176 expect(ran).toBe(false);177 });178179 it("persists peach_last_sync_result to storage after a successful sync", async () => {180 await upsertPairedDevice(ANDROID);181 setSyncRunner(async () => ({ ok: true, entriesReceived: 3, entriesSent: 1 }));182 await triggerSyncIfReachable({ reason: "manual" });183 184 const raw = await (globalThis as unknown as { chrome: { storage: { local: { get(k: string): Promise<Record<string, unknown>> } } } })185 .chrome.storage.local.get("peach_last_sync_result");186 expect(raw.peach_last_sync_result).toEqual({ entriesReceived: 3, entriesSent: 1 });187 });188189 it("hydratePersistedSyncState restores lastSyncAt across SW restart simulation", async () => {190 191 await (globalThis as unknown as { chrome: { storage: { local: { set(v: Record<string, unknown>): Promise<void> } } } })192 .chrome.storage.local.set({ peach_last_sync_at: 1_700_005_000_000 });193 _resetSyncTriggerForTest();194 expect(getSyncState().lastSyncAt).toBeUndefined();195 await hydratePersistedSyncState();196 expect(getSyncState().lastSyncAt).toBe(1_700_005_000_000);197 });198});