on-zero 0.4.26 → 0.4.27

package/dist/cjs/httpPull/transport.test.cjs

@@ -0,0 +1,568 @@
+var import_zero = require("@rocicorp/zero");
+var import_vitest = require("vitest");
+var import_fixtureSchema = require("./fixtureSchema.cjs");
+var import_httpPullTransport = require("../httpPullTransport.cjs");
+const ORIGIN = "https://zero-http.local";
+const zeros = [];
+const transports = [];
+let storageID = 0;
+(0, import_vitest.afterEach)(async () => {
+  while (zeros.length) await zeros.pop()?.close();
+  while (transports.length) transports.pop()?.uninstall();
+  import_vitest.vi.useRealTimers();
+});
+(0, import_vitest.describe)("zero-http transport", () => {
+  (0, import_vitest.test)("connect + complete hydrates a stock Zero materialized query", async () => {
+    const requests = [];
+    let cookie = 0;
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      requests.push(request);
+      (0, import_vitest.expect)(request.path).toBe("/pull");
+      (0, import_vitest.expect)(request.headers.authorization).toBe("Bearer token-u1");
+      return jsonResponse({
+        cookie: ++cookie,
+        lastMutationIDChanges: {},
+        rowsPatch: [{
+          op: "clear"
+        }, {
+          op: "put",
+          tableName: "user",
+          value: {
+            id: "u1",
+            name: "ada"
+          }
+        }, {
+          op: "put",
+          tableName: "project",
+          value: {
+            id: "p1",
+            ownerId: "u1",
+            name: "control"
+          }
+        }, {
+          op: "put",
+          tableName: "member",
+          value: {
+            id: "m1",
+            projectId: "p1",
+            userId: "u1"
+          }
+        }]
+      });
+    });
+    const transport = install(fetch);
+    const zero = createZero();
+    const view = zero.query.project.related("members").materialize();
+    const data = await waitForComplete(view);
+    view.destroy();
+    (0, import_vitest.expect)(transport.connections).toBe(1);
+    (0, import_vitest.expect)(data).toEqual([{
+      id: "p1",
+      ownerId: "u1",
+      name: "control",
+      members: [{
+        id: "m1",
+        projectId: "p1",
+        userId: "u1"
+      }]
+    }]);
+    (0, import_vitest.expect)(requests[0].body.cookie).toBeNull();
+    (0, import_vitest.expect)(requests[0].body.clientID).toEqual(import_vitest.expect.any(String));
+    (0, import_vitest.expect)(requests[0].body.clientGroupID).toEqual(import_vitest.expect.any(String));
+  });
+  (0, import_vitest.test)("push frames POST to /push, resolve server promises, and schedule a follow-up pull", async () => {
+    const requests = [];
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      requests.push(request);
+      if (request.path === "/pull") {
+        return jsonResponse({
+          cookie: request.body.cookie,
+          unchanged: true
+        });
+      }
+      (0, import_vitest.expect)(request.path).toBe("/push");
+      const mutation2 = request.body.mutations[0];
+      return jsonResponse({
+        pushResponse: {
+          mutations: [{
+            id: {
+              clientID: mutation2.clientID,
+              id: mutation2.id
+            },
+            result: {}
+          }]
+        }
+      });
+    });
+    install(fetch);
+    const zero = createZero();
+    await eventually(() => (0, import_vitest.expect)(requests.filter(request => request.path === "/pull").length).toBe(1));
+    const pullsBeforePush = requests.filter(request => request.path === "/pull").length;
+    const mutation = zero.mutate.project.create({
+      id: "p1",
+      ownerId: "u1",
+      name: "created"
+    });
+    await mutation.client;
+    await mutation.server;
+    const push = requests.find(request => request.path === "/push");
+    (0, import_vitest.expect)(push?.headers.authorization).toBe("Bearer token-u1");
+    (0, import_vitest.expect)(push?.body).toMatchObject({
+      clientGroupID: import_vitest.expect.any(String),
+      pushVersion: 1,
+      requestID: import_vitest.expect.any(String),
+      mutations: [{
+        type: "custom",
+        name: "project|create",
+        id: 1,
+        clientID: import_vitest.expect.any(String),
+        args: [{
+          id: "p1",
+          ownerId: "u1",
+          name: "created"
+        }]
+      }]
+    });
+    await eventually(() => (0, import_vitest.expect)(requests.filter(request => request.path === "/pull").length).toBe(pullsBeforePush + 1));
+  });
+  (0, import_vitest.test)("updateAuth frame updates bearer headers for later requests", async () => {
+    const requests = [];
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      requests.push(request);
+      (0, import_vitest.expect)(request.path).toBe("/pull");
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    const transport = install(fetch);
+    const {
+      socket
+    } = openRawSocketWithMessages({
+      authToken: "token-old"
+    });
+    await eventually(() => (0, import_vitest.expect)(requests.length).toBe(1));
+    (0, import_vitest.expect)(requests[0].headers.authorization).toBe("Bearer token-old");
+    socket.send(JSON.stringify(["updateAuth", {
+      auth: "token-new"
+    }]));
+    await transport.pull();
+    (0, import_vitest.expect)(requests.at(-1)?.headers.authorization).toBe("Bearer token-new");
+  });
+  (0, import_vitest.test)("push frames are serialized per socket", async () => {
+    const firstPushStarted = defer();
+    const releaseFirstPush = defer();
+    const pushIDs = [];
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      if (request.path === "/pull") {
+        return jsonResponse({
+          cookie: request.body.cookie,
+          unchanged: true
+        });
+      }
+      (0, import_vitest.expect)(request.path).toBe("/push");
+      const mutationID = request.body.mutations[0].id;
+      pushIDs.push(mutationID);
+      if (mutationID === 1) {
+        firstPushStarted.resolve();
+        await releaseFirstPush.promise;
+      }
+      return jsonResponse({
+        pushResponse: {
+          mutations: request.body.mutations.map(mutation => ({
+            id: {
+              clientID: mutation.clientID,
+              id: mutation.id
+            },
+            result: {}
+          }))
+        }
+      });
+    });
+    install(fetch);
+    const {
+      messages,
+      socket
+    } = openRawSocketWithMessages();
+    await eventually(() => (0, import_vitest.expect)(messages.some(message => message[0] === "connected")).toBe(true));
+    socket.send(JSON.stringify(["push", pushBody(1)]));
+    await firstPushStarted.promise;
+    socket.send(JSON.stringify(["push", pushBody(2)]));
+    await sleep(25);
+    (0, import_vitest.expect)(pushIDs).toEqual([1]);
+    releaseFirstPush.resolve();
+    await eventually(() => (0, import_vitest.expect)(pushIDs).toEqual([1, 2]));
+    await eventually(() => (0, import_vitest.expect)(messages.filter(message => message[0] === "pushResponse")).toHaveLength(2));
+    (0, import_vitest.expect)(messages.filter(message => message[0] === "pushResponse").map(message => message[1].mutations[0].id.id)).toEqual([1, 2]);
+  });
+  (0, import_vitest.test)("cookie discipline skips unchanged pokes, chains changed pokes, and coalesces concurrent pulls", async () => {
+    const requests = [];
+    const responses = [{
+      cookie: 1,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }]
+    }, {
+      cookie: 1,
+      unchanged: true
+    }, {
+      cookie: 2,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }, {
+        op: "put",
+        tableName: "project",
+        value: {
+          id: "p2",
+          ownerId: "u1",
+          name: "second"
+        }
+      }]
+    }, {
+      cookie: 3,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }, {
+        op: "put",
+        tableName: "project",
+        value: {
+          id: "p3",
+          ownerId: "u1",
+          name: "third"
+        }
+      }]
+    }];
+    const deferred = defer();
+    responses.push(deferred.promise);
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      try {
+        const request = recordRequest(input, init);
+        requests.push(request);
+        const response = responses.shift();
+        if (!response) throw new Error("missing canned response");
+        return jsonResponse(await response);
+      } finally {
+        inFlight--;
+      }
+    });
+    const transport = install(fetch);
+    const messages = openRawSocket();
+    await eventually(() => (0, import_vitest.expect)(messages.some(message => message[0] === "pokeEnd")).toBe(true));
+    (0, import_vitest.expect)(requests[0].body.cookie).toBeNull();
+    (0, import_vitest.expect)(findMessage(messages, "pokeStart")[1].baseCookie).toBeNull();
+    (0, import_vitest.expect)(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000001");
+    messages.length = 0;
+    await transport.pull();
+    (0, import_vitest.expect)(messages.filter(message => message[0].startsWith("poke"))).toEqual([]);
+    (0, import_vitest.expect)(requests[1].body.cookie).toBe(1);
+    await transport.pull();
+    (0, import_vitest.expect)(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000001");
+    (0, import_vitest.expect)(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000002");
+    (0, import_vitest.expect)(requests[2].body.cookie).toBe(1);
+    messages.length = 0;
+    await transport.pull();
+    (0, import_vitest.expect)(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000002");
+    (0, import_vitest.expect)(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000003");
+    (0, import_vitest.expect)(requests[3].body.cookie).toBe(2);
+    messages.length = 0;
+    const concurrentA = transport.pull();
+    const concurrentB = transport.pull();
+    await eventually(() => (0, import_vitest.expect)(requests.length).toBe(5));
+    deferred.resolve({
+      cookie: 4,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }]
+    });
+    await Promise.all([concurrentA, concurrentB]);
+    (0, import_vitest.expect)(requests.length).toBe(5);
+    (0, import_vitest.expect)(maxInFlight).toBe(1);
+    (0, import_vitest.expect)(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000003");
+    (0, import_vitest.expect)(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000004");
+  });
+  (0, import_vitest.test)("unchanged pull flushes late query registration to complete", async () => {
+    const requests = [];
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      requests.push(request);
+      (0, import_vitest.expect)(request.path).toBe("/pull");
+      if (request.body.cookie === null) {
+        return jsonResponse({
+          cookie: 1,
+          lastMutationIDChanges: {},
+          rowsPatch: [{
+            op: "clear"
+          }, {
+            op: "put",
+            tableName: "user",
+            value: {
+              id: "u1",
+              name: "ada"
+            }
+          }, {
+            op: "put",
+            tableName: "project",
+            value: {
+              id: "p1",
+              ownerId: "u1",
+              name: "first"
+            }
+          }]
+        });
+      }
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    install(fetch);
+    const zero = createZero();
+    const projectView = zero.query.project.materialize();
+    await waitForComplete(projectView);
+    const userView = zero.query.user.materialize();
+    const users = await waitForComplete(userView);
+    (0, import_vitest.expect)(users).toEqual([{
+      id: "u1",
+      name: "ada"
+    }]);
+    (0, import_vitest.expect)(requests.at(-1)?.body.cookie).toBe(1);
+    projectView.destroy();
+    userView.destroy();
+  });
+  (0, import_vitest.test)("ping is answered locally and the stock Zero connection survives idle ping", async () => {
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      (0, import_vitest.expect)(request.path).toBe("/pull");
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    const transport = install(fetch);
+    const zero = createZero({
+      pingTimeoutMs: 10
+    });
+    await eventually(() => (0, import_vitest.expect)(zero.connection.state.current.name).toBe("connected"));
+    await sleep(40);
+    (0, import_vitest.expect)(zero.connection.state.current.name).toBe("connected");
+    (0, import_vitest.expect)(transport.connections).toBe(1);
+  });
+  (0, import_vitest.test)("401 pull failure closes the fake socket without materializing data", async () => {
+    const requests = [];
+    const fetch = import_vitest.vi.fn(async (input, init) => {
+      const request = recordRequest(input, init);
+      requests.push(request);
+      (0, import_vitest.expect)(request.path).toBe("/pull");
+      return jsonResponse({
+        error: "unauthorized"
+      }, {
+        status: 401
+      });
+    });
+    const transport = install(fetch);
+    const zero = createZero();
+    const view = zero.query.project.materialize();
+    const emissions = [];
+    const cleanup = view.addListener((data, resultType) => {
+      emissions.push({
+        data: JSON.parse(JSON.stringify(data)),
+        resultType
+      });
+    });
+    await eventually(() => (0, import_vitest.expect)(requests.length).toBeGreaterThan(0));
+    await eventually(() => (0, import_vitest.expect)(zero.connection.state.current.name).toBe("needs-auth"));
+    await sleep(25);
+    (0, import_vitest.expect)(transport.connections).toBe(0);
+    (0, import_vitest.expect)(emissions.flatMap(emission => emission.data)).toEqual([]);
+    (0, import_vitest.expect)(view.data).toEqual([]);
+    cleanup();
+    view.destroy();
+  });
+  (0, import_vitest.test)("non-origin WebSockets pass through to the native implementation", () => {
+    const previous = globalThis.WebSocket;
+    class NativeWebSocket {
+      constructor(url, protocols) {
+        this.url = url;
+        this.protocols = protocols;
+      }
+      static CONNECTING = 0;
+      static OPEN = 1;
+      static CLOSING = 2;
+      static CLOSED = 3;
+    }
+    globalThis.WebSocket = NativeWebSocket;
+    const transport = (0, import_httpPullTransport.installHttpPullTransport)({
+      origin: ORIGIN,
+      fetch: import_vitest.vi.fn()
+    });
+    const socket = new WebSocket("wss://elsewhere.local/socket", "native");
+    (0, import_vitest.expect)(socket).toBeInstanceOf(NativeWebSocket);
+    (0, import_vitest.expect)(socket.url).toBe("wss://elsewhere.local/socket");
+    transport.uninstall();
+    (0, import_vitest.expect)(globalThis.WebSocket).toBe(NativeWebSocket);
+    globalThis.WebSocket = previous;
+  });
+  (0, import_vitest.test)("ensureHttpPullTransport installs once per origin", () => {
+    const origin = "http://127.0.0.1:65501";
+    const first = (0, import_httpPullTransport.ensureHttpPullTransport)({
+      origin,
+      fetch: import_vitest.vi.fn()
+    });
+    const second = (0, import_httpPullTransport.ensureHttpPullTransport)({
+      origin,
+      fetch: import_vitest.vi.fn()
+    });
+    (0, import_vitest.expect)(second).toBe(first);
+    first.uninstall();
+  });
+});
+function install(fetch) {
+  const transport = (0, import_httpPullTransport.installHttpPullTransport)({
+    origin: ORIGIN,
+    fetch
+  });
+  transports.push(transport);
+  return transport;
+}
+function createZero(options = {}) {
+  const zero = new import_zero.Zero({
+    server: ORIGIN,
+    userID: "u1",
+    auth: "token-u1",
+    schema: import_fixtureSchema.zeroHttpFixtureSchema,
+    kvStore: "mem",
+    storageKey: `zero-http-test-${++storageID}`,
+    mutators: import_fixtureSchema.zeroHttpFixtureMutators,
+    pingTimeoutMs: options.pingTimeoutMs
+  });
+  zeros.push(zero);
+  return zero;
+}
+function recordRequest(input, init) {
+  const url = new URL(String(input));
+  const headers = Object.fromEntries(Object.entries(init?.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
+  return {
+    url: url.toString(),
+    path: url.pathname,
+    headers,
+    body: init?.body ? JSON.parse(String(init.body)) : void 0
+  };
+}
+function jsonResponse(body, init) {
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    statusText: init?.statusText,
+    headers: {
+      "content-type": "application/json",
+      ...init?.headers
+    }
+  });
+}
+async function waitForComplete(view) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timed out waiting for complete query")), 5e3);
+    let cleanup = () => {};
+    cleanup = view.addListener((data, resultType) => {
+      if (resultType !== "complete") return;
+      clearTimeout(timeout);
+      cleanup();
+      resolve(JSON.parse(JSON.stringify(data)));
+    });
+  });
+}
+async function eventually(assertion, timeout = 1e3) {
+  const started = Date.now();
+  let lastError;
+  while (Date.now() - started < timeout) {
+    try {
+      await assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      await sleep(10);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+function openRawSocket() {
+  return openRawSocketWithMessages().messages;
+}
+function openRawSocketWithMessages(opts) {
+  const url = new URL(`${ORIGIN}/sync/v51/connect`);
+  url.protocol = "wss:";
+  url.searchParams.set("clientID", "c1");
+  url.searchParams.set("clientGroupID", "cg1");
+  url.searchParams.set("userID", "u1");
+  url.searchParams.set("baseCookie", "");
+  url.searchParams.set("lmid", "0");
+  url.searchParams.set("wsid", "ws-test");
+  const messages = [];
+  const socket = new WebSocket(url, encodeSecProtocol(["initConnection", {
+    desiredQueriesPatch: opts?.desiredQueriesPatch ?? []
+  }], opts?.authToken ?? "token-u1"));
+  socket.addEventListener("message", event => {
+    messages.push(JSON.parse(String(event.data)));
+  });
+  return {
+    messages,
+    socket
+  };
+}
+function pushBody(id) {
+  return {
+    clientGroupID: "cg1",
+    pushVersion: 1,
+    requestID: `push-${id}`,
+    timestamp: Date.now(),
+    mutations: [{
+      type: "custom",
+      name: "project|create",
+      id,
+      clientID: "c1",
+      args: [{
+        id: `p${id}`,
+        ownerId: "u1",
+        name: `project ${id}`
+      }]
+    }]
+  };
+}
+function findMessage(messages, type) {
+  const message = messages.find(item => item[0] === type);
+  (0, import_vitest.expect)(message).toBeDefined();
+  return message;
+}
+function encodeSecProtocol(initConnectionMessage, authToken) {
+  return encodeURIComponent(Buffer.from(JSON.stringify({
+    initConnectionMessage,
+    authToken
+  })).toString("base64"));
+}
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}