1
import { describe, expect, it, vi } from "vitest";
2
import {
3
  getDocSyncStatus,
4
  reconcileDocSyncProvider,
5
  shouldConnectDocSyncProvider,
6
  type SyncProviderLike,
7
} from "@/client/lib/doc-sync-provider";
8
 
9
function createProvider(overrides: Partial<SyncProviderLike> = {}): SyncProviderLike {
10
  return {
11
    connect: vi.fn().mockResolvedValue(undefined),
12
    disconnect: vi.fn(),
13
    shouldConnect: false,
14
    wsconnected: false,
15
    wsconnecting: false,
16
    synced: false,
17
    ...overrides,
18
  };
19
}
20
 
21
describe("shouldConnectDocSyncProvider", () => {
22
  it("requires the browser to be online", () => {
23
    expect(
24
      shouldConnectDocSyncProvider({
25
        online: false,
26
        accessToken: "token",
27
      }),
28
    ).toBe(false);
29
  });
30
 
31
  it("connects authenticated workspace sessions when online", () => {
32
    expect(
33
      shouldConnectDocSyncProvider({
34
        online: true,
35
        accessToken: "token",
36
      }),
37
    ).toBe(true);
38
  });
39
 
40
  it("connects shared sessions when online", () => {
41
    expect(
42
      shouldConnectDocSyncProvider({
43
        online: true,
44
        shareToken: "share-token",
45
      }),
46
    ).toBe(true);
47
  });
48
 
49
  it("stays disconnected without any auth material", () => {
50
    expect(
51
      shouldConnectDocSyncProvider({
52
        online: true,
53
      }),
54
    ).toBe(false);
55
  });
56
});
57
 
58
describe("getDocSyncStatus", () => {
59
  it("reports disconnected when the browser is offline", () => {
60
    expect(getDocSyncStatus(createProvider({ wsconnected: true }), false)).toBe("disconnected");
61
  });
62
 
63
  it("reports connected for an active websocket", () => {
64
    expect(getDocSyncStatus(createProvider({ wsconnected: true, shouldConnect: true }), true)).toBe("connected");
65
  });
66
 
67
  it("reports connecting while the provider intends to reconnect", () => {
68
    expect(getDocSyncStatus(createProvider({ shouldConnect: true }), true)).toBe("connecting");
69
  });
70
 
71
  it("reports disconnected for an intentionally parked provider", () => {
72
    expect(getDocSyncStatus(createProvider(), true)).toBe("disconnected");
73
  });
74
});
75
 
76
describe("reconcileDocSyncProvider", () => {
77
  it("connects once when the provider should become live", () => {
78
    const provider = createProvider();
79
 
80
    reconcileDocSyncProvider(provider, true);
81
 
82
    expect(provider.connect).toHaveBeenCalledTimes(1);
83
    expect(provider.disconnect).not.toHaveBeenCalled();
84
  });
85
 
86
  it("does not reconnect an already-live provider", () => {
87
    const provider = createProvider({ shouldConnect: true, wsconnecting: true });
88
 
89
    reconcileDocSyncProvider(provider, true);
90
 
91
    expect(provider.connect).not.toHaveBeenCalled();
92
    expect(provider.disconnect).not.toHaveBeenCalled();
93
  });
94
 
95
  it("disconnects a provider that should stop syncing", () => {
96
    const provider = createProvider({ shouldConnect: true, wsconnected: true });
97
 
98
    reconcileDocSyncProvider(provider, false);
99
 
100
    expect(provider.disconnect).toHaveBeenCalledTimes(1);
101
    expect(provider.connect).not.toHaveBeenCalled();
102
  });
103
 
104
  it("leaves an already-disconnected provider alone", () => {
105
    const provider = createProvider();
106
 
107
    reconcileDocSyncProvider(provider, false);
108
 
109
    expect(provider.disconnect).not.toHaveBeenCalled();
110
    expect(provider.connect).not.toHaveBeenCalled();
111
  });
112
});