Files
outline/app/utils/multiplayer/CollaborationProvider.test.ts
Tom Moor a6b50dcc11 fix: Reduce false unsynced changes warnings when leaving a document (#14006)
* fix: Only warn about unsynced changes when navigating to a different document

* fix: Do not prompt about uploading images when staying on the same document

* fix: Do not report edits before the first sync as unsynced when stored locally

* fix: Treat opening a revision as leaving the document
2026-10-09 21:11:36 -04:00

234 lines
6.0 KiB
TypeScript

import { MessageType } from "@hocuspocus/provider";
import * as encoding from "lib0/encoding";
import WebSocket from "ws";
import { writeUpdate } from "y-protocols/sync";
import * as Y from "yjs";
import {
CollaborationProvider,
type SyncStateEvent,
} from "./CollaborationProvider";
describe("CollaborationProvider", () => {
let doc: Y.Doc;
let provider: CollaborationProvider;
let events: SyncStateEvent[];
const edit = (origin?: unknown) => {
doc.transact(() => doc.getText("default").insert(0, "a"), origin);
};
const updateMessage = (update: Uint8Array) => {
const encoder = encoding.createEncoder();
encoding.writeVarUint(encoder, MessageType.Sync);
writeUpdate(encoder, update);
return new Uint8Array(encoding.toUint8Array(encoder)).buffer;
};
beforeEach(() => {
vi.useFakeTimers();
doc = new Y.Doc();
events = [];
provider = new CollaborationProvider({
url: "ws://localhost",
name: "test",
document: doc,
connect: false,
});
provider.on("syncStateChange", (event: SyncStateEvent) => {
events.push(event);
});
});
afterEach(() => {
provider.destroy();
vi.useRealTimers();
});
it("starts without pending changes", () => {
expect(provider.hasPendingChanges).toBe(false);
expect(provider.hasLocalPersistence).toBe(false);
});
it("reports an edit made while disconnected immediately", () => {
edit();
expect(provider.hasPendingChanges).toBe(true);
expect(events).toEqual([
{ hasUnsyncedChanges: true, hasLocalPersistence: false },
]);
});
it("ignores updates that came from the provider itself", () => {
edit(provider);
expect(provider.hasPendingChanges).toBe(false);
expect(events).toEqual([]);
});
it("waits for the grace period while connected", () => {
provider.synced = true;
edit();
expect(provider.hasPendingChanges).toBe(false);
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(true);
expect(events).toHaveLength(1);
});
it("clears pending changes once the server confirms a full sync", () => {
edit();
edit();
expect(provider.hasPendingChanges).toBe(true);
provider.synced = true;
expect(provider.hasPendingChanges).toBe(false);
expect(events.at(-1)).toEqual({
hasUnsyncedChanges: false,
hasLocalPersistence: false,
});
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(false);
});
it.each([0, 2000])(
"clears pending changes when the server echoes an update after %i ms",
(delay) => {
provider.synced = true;
edit();
vi.advanceTimersByTime(delay);
provider.onMessage({
data: updateMessage(Y.encodeStateAsUpdate(doc)),
type: "message",
target: new WebSocket(null),
});
expect(provider.hasPendingChanges).toBe(false);
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(false);
}
);
it("cancels the warning when a broadcast clears the pending count", () => {
provider.synced = true;
edit();
provider.broadcastChannelSubscriber(
updateMessage(Y.encodeStateAsUpdate(doc))
);
expect(provider.hasUnsyncedChanges).toBe(false);
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(false);
expect(events).toEqual([]);
});
it("clears an existing warning when a broadcast clears the pending count", () => {
provider.synced = true;
edit();
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(true);
provider.broadcastChannelSubscriber(
updateMessage(Y.encodeStateAsUpdate(doc))
);
expect(provider.hasPendingChanges).toBe(false);
expect(events.at(-1)).toEqual({
hasUnsyncedChanges: false,
hasLocalPersistence: false,
});
});
it("keeps pending changes while the connection is down", () => {
provider.synced = true;
edit();
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(true);
provider.synced = false;
expect(provider.hasPendingChanges).toBe(true);
expect(events).toHaveLength(1);
});
describe("with local persistence", () => {
let stopLocalProvider: () => void;
beforeEach(() => {
provider.destroy();
const listeners = new Set<() => void>();
stopLocalProvider = () => listeners.forEach((listener) => listener());
provider = new CollaborationProvider({
url: "ws://localhost",
name: "test",
document: doc,
connect: false,
localProvider: {
stopped: false,
onStop: (listener: () => void) => {
listeners.add(listener);
return () => {
listeners.delete(listener);
};
},
},
});
provider.on("syncStateChange", (event: SyncStateEvent) => {
events.push(event);
});
});
it("does not report edits made before the first sync", () => {
expect(provider.hasLocalPersistence).toBe(true);
edit();
expect(provider.hasPendingChanges).toBe(false);
expect(events).toEqual([]);
});
it("reports edits made after the connection drops", () => {
provider.synced = true;
provider.synced = false;
edit();
expect(provider.hasPendingChanges).toBe(true);
expect(events.at(-1)).toEqual({
hasUnsyncedChanges: true,
hasLocalPersistence: true,
});
});
it("reports edits made before the first sync when local persistence stops", () => {
edit();
expect(provider.hasPendingChanges).toBe(false);
stopLocalProvider();
expect(provider.hasLocalPersistence).toBe(false);
expect(events.at(-1)).toEqual({
hasUnsyncedChanges: true,
hasLocalPersistence: false,
});
});
});
it("does not report after being destroyed", () => {
provider.synced = true;
edit();
provider.destroy();
vi.advanceTimersByTime(2000);
expect(provider.hasPendingChanges).toBe(false);
});
});