add/improve cluster unit tests

Author: williamstein

src/packages/backend/conat/test/cluster/cluster-sticky.test.ts

@@ -16,13 +16,15 @@ describe("create cluster of two nodes, and verify that *sticky* subs properly wo
     ({ server: server1, client: client1 } = await createClusterNode({
       clusterName: "cluster0",
       id: "1",
-      systemAccountPassword: "squeamish",
+      autoscanInterval: 100,
+      longAutoscanInterval: 1000,
     }));
     client1b = server1.client();
     ({ server: server2, client: client2 } = await createClusterNode({
       clusterName: "cluster0",
       id: "2",
-      systemAccountPassword: "ossifrage",
+      autoscanInterval: 100,
+      longAutoscanInterval: 1000,
     }));
     await server1.join(server2.address());
     await server2.join(server1.address());
@@ -60,11 +62,11 @@ describe("create cluster of two nodes, and verify that *sticky* subs properly wo
 
   it("send messages and note they all go to the same target -- next the hard case across the cluster", async () => {
     // NOTE: if we do this test without waiting for consistent state, it will definitely
-    // fail sometimes, since server2 literally doesn't know enough about the servers yet, 
+    // fail sometimes, since server2 literally doesn't know enough about the servers yet,
     // so has to make a different choice.  Services of course must account for the fact that
     // for the first moments of their existence, sticky routing can't work.
     await waitForConsistentState([server1, server2]);
-    
+
     await client2.waitForInterest(subject);
     for (let i = 0; i < count; i++) {
       await client2.publish(subject, "hi");
@@ -73,6 +75,45 @@ describe("create cluster of two nodes, and verify that *sticky* subs properly wo
     expect(recv1 + recv1b).toEqual(2 * count);
     expect(recv1 * recv1b).toEqual(0);
   });
+
+  let server3, client3;
+  it("add a third node", async () => {
+    const { client, server } = await createClusterNode({
+      clusterName: "cluster0",
+      autoscanInterval: 100,
+      longAutoscanInterval: 5000,
+      id: "3",
+    });
+    server3 = server;
+    client3 = client;
+    await server1.join(server.address());
+  });
+
+  it("waits for consistent state -- this verifies, e.g., that sticky state is equal", async () => {
+    await waitForConsistentState([server1, server2, server3]);
+  });
+
+  it("client connected to server3 also routes properly", async () => {
+    const total = recv1 + recv1b;
+    await client3.waitForInterest(subject);
+    for (let i = 0; i < count; i++) {
+      await client3.publish(subject, "hi");
+    }
+    await wait({ until: () => recv1 + recv1b >= total + count });
+    expect(recv1 + recv1b).toEqual(total + count);
+    expect(recv1 * recv1b).toEqual(0);
+  });
+
+  it("client1 and client2 still route properly", async () => {
+    const total = recv1 + recv1b;
+    for (let i = 0; i < count; i++) {
+      await client1.publish(subject, "hi");
+      await client2.publish(subject, "hi");
+    }
+    await wait({ until: () => recv1 + recv1b >= total + 2 * count });
+    expect(recv1 + recv1b).toEqual(total + 2 * count);
+    expect(recv1 * recv1b).toEqual(0);
+  });
 });
 
 afterAll(after);

src/packages/backend/conat/test/setup.ts

@@ -191,7 +191,10 @@ export async function waitForConsistentState(
             // @ts-ignore
             const link = servers[j].clusterLinks[clusterName]?.[servers[i].id];
             if (link == null) {
-              throw Error(`node ${j} is not connected to node ${i}`);
+              if (Date.now() - start > 3000) {
+                console.log(`node ${j} is not connected to node ${i}`);
+              }
+              return false;
             }
             const hashLink = link.hash();
             const x = link.interest.serialize().patterns;