@nymphjs/pubsub 1.0.0-beta.12 → 1.0.0-beta.120

package/src/PubSub.test.ts

@@ -1,16 +1,23 @@
 import express from 'express';
+import ws from 'websocket';
 import SQLite3Driver from '@nymphjs/driver-sqlite3';
 import { Nymph as NymphServer } from '@nymphjs/nymph';
-import { Nymph, PubSub } from '@nymphjs/client-node';
+import type { PubSubSubscription, PubSubUpdate } from '@nymphjs/client';
+import { Nymph, PubSub } from '@nymphjs/client';
 import createRestServer from '@nymphjs/server';
 import {
   EmployeeModel as EmployeeModelClass,
   Employee as EmployeeClass,
   EmployeeData,
+  RestrictedModel as RestrictedModelClass,
+  Restricted as RestrictedClass,
+  PubSubDisabledModel as PubSubDisabledModelClass,
+  PubSubDisabled as PubSubDisabledClass,
+  PubSubDisabledData,
 } from '@nymphjs/server/dist/testArtifacts.js';
 
-import createServer from './index';
-import PubSubServer from './PubSub';
+import createServer from './index.js';
+import PubSubServer from './PubSub.js';
 
 const sqliteConfig = {
   filename: ':memory:',
@@ -18,28 +25,35 @@ const sqliteConfig = {
 
 const pubSubConfig = {
   originIsAllowed: () => true,
-  entries: ['ws://localhost:5081/'],
+  entries: ['ws://localhost:5083/'],
   logger: () => {},
 };
 
 const nymphServer = new NymphServer({}, new SQLite3Driver(sqliteConfig));
 const EmployeeModel = nymphServer.addEntityClass(EmployeeModelClass);
-PubSubServer.initPublisher(pubSubConfig, nymphServer);
+const RestrictedModel = nymphServer.addEntityClass(RestrictedModelClass);
+const PubSubDisabledModel = nymphServer.addEntityClass(
+  PubSubDisabledModelClass,
+);
+const removePublisher = PubSubServer.initPublisher(pubSubConfig, nymphServer);
 
 const app = express();
 app.use(createRestServer(nymphServer));
-const server = app.listen(5080);
+const server = app.listen(5082);
 
-const pubsubServer = createServer(5081, pubSubConfig, nymphServer);
+const pubsubServer = createServer(5083, pubSubConfig, nymphServer);
 
 const nymphOptions = {
-  restUrl: 'http://localhost:5080/',
-  pubsubUrl: 'ws://localhost:5081/',
+  restUrl: 'http://localhost:5082/',
+  pubsubUrl: 'ws://localhost:5083/',
   noConsole: true,
+  WebSocket: ws.w3cwebsocket as unknown as typeof WebSocket,
 };
 const nymph = new Nymph(nymphOptions);
 const pubsub = new PubSub(nymphOptions, nymph);
 const Employee = nymph.addEntityClass(EmployeeClass);
+const Restricted = nymph.addEntityClass(RestrictedClass);
+const PubSubDisabled = nymph.addEntityClass(PubSubDisabledClass);
 
 describe('Nymph REST Server and Client', () => {
   async function createJane() {
@@ -93,22 +107,22 @@ describe('Nymph REST Server and Client', () => {
   it('notified of new match', async () => {
     let jane: Promise<EmployeeClass>;
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       let updated = false;
       const subscription = pubsub.subscribeEntities(
         { class: Employee },
         {
           type: '&',
           equal: ['name', 'Jane Doe'],
-        }
+        },
       )(async (update) => {
         if (updated) {
           expect('added' in update && update.added).toEqual((await jane).guid);
           expect('data' in update && update.data.guid).toEqual(
-            (await jane).guid
+            (await jane).guid,
           );
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         } else {
           expect(update).toEqual([]);
           updated = true;
@@ -118,11 +132,180 @@ describe('Nymph REST Server and Client', () => {
     });
   });
 
+  it('notified of new match only after transaction committed', async () => {
+    let guid: string;
+    let committed = false;
+
+    await new Promise<void>((resolve) => {
+      let updated = false;
+      const subscription = pubsub.subscribeEntities(
+        { class: Employee },
+        {
+          type: '&',
+          equal: ['name', 'Steve Transaction'],
+        },
+      )(async (update) => {
+        if (updated) {
+          if (committed) {
+            expect('added' in update && update.added).toEqual(guid);
+            expect('data' in update && update.data.guid).toEqual(guid);
+          } else {
+            throw new Error('Update arrived before transaction committed.');
+          }
+          subscription.unsubscribe();
+          resolve();
+        } else {
+          expect(update).toEqual([]);
+          updated = true;
+          const tnymph = await nymphServer.startTransaction('steve');
+          const Employee = tnymph.getEntityClass(EmployeeModel);
+          const steve = await Employee.factory();
+          steve.name = 'Steve Transaction';
+          steve.current = true;
+          steve.salary = 8000000;
+          steve.startDate = Date.now();
+          steve.subordinates = [];
+          steve.title = 'Seniorer Person';
+          try {
+            await steve.$save();
+            guid = steve.guid as string;
+            await new Promise<void>((res) => setTimeout(res, 1000));
+            committed = true;
+            await tnymph.commit('steve');
+          } catch (e: any) {
+            console.error('Error creating entity: ', e);
+            throw e;
+          }
+        }
+      });
+    });
+  });
+
+  it('not notified of new match when transaction rolled back', async () => {
+    let guid: string;
+
+    await new Promise<void>((resolve) => {
+      let updated = false;
+      const subscription = pubsub.subscribeEntities(
+        { class: Employee },
+        {
+          type: '&',
+          equal: ['name', 'Steve Rollback'],
+        },
+      )(async (update) => {
+        if (updated) {
+          if ('added' in update && update.added === guid) {
+            throw new Error('Update arrived after transaction rolled back.');
+          }
+          throw new Error('Update arrived unrelated to transaction.');
+        } else {
+          expect(update).toEqual([]);
+          updated = true;
+          const tnymph = await nymphServer.startTransaction('steve');
+          const Employee = tnymph.getEntityClass(EmployeeModel);
+          const steve = await Employee.factory();
+          steve.name = 'Steve Rollback';
+          steve.current = true;
+          steve.salary = 8000000;
+          steve.startDate = Date.now();
+          steve.subordinates = [];
+          steve.title = 'Seniorer Person';
+          try {
+            await steve.$save();
+            guid = steve.guid as string;
+            await new Promise<void>((res) => setTimeout(res, 600));
+            await tnymph.rollback('steve');
+            await new Promise<void>((res) => setTimeout(res, 600));
+            subscription.unsubscribe();
+            resolve();
+          } catch (e: any) {
+            console.error('Error creating entity: ', e);
+            throw e;
+          }
+        }
+      });
+    });
+  });
+
+  it('notified of new match after complex transactions committed', async () => {
+    let guid: string;
+    let committed = false;
+
+    await new Promise<void>((resolve) => {
+      let updated = false;
+      const subscription = pubsub.subscribeEntities(
+        { class: Employee },
+        {
+          type: '&',
+          equal: ['name', 'Steve Complex'],
+        },
+      )(async (update) => {
+        if (updated) {
+          if (committed) {
+            expect('added' in update && update.added).toEqual(guid);
+            expect('data' in update && update.data.guid).toEqual(guid);
+          } else {
+            throw new Error('Update arrived before transaction committed.');
+          }
+          subscription.unsubscribe();
+          resolve();
+        } else {
+          expect(update).toEqual([]);
+          updated = true;
+          const tnymphTop = await nymphServer.startTransaction('steve-top');
+
+          // Start a transaction that ultimately gets rolled back.
+          const tnymphB = await tnymphTop.startTransaction('steve-b');
+          const EmployeeB = tnymphB.getEntityClass(EmployeeModel);
+          const badSteve = await EmployeeB.factory();
+          badSteve.name = 'Steve Complex';
+          badSteve.current = true;
+          badSteve.salary = 8000000;
+          badSteve.startDate = Date.now();
+          badSteve.subordinates = [];
+          badSteve.title = 'Seniorer Person';
+          try {
+            await badSteve.$save();
+            await new Promise<void>((res) => setTimeout(res, 200));
+            await tnymphB.rollback('steve-b');
+            await new Promise<void>((res) => setTimeout(res, 200));
+          } catch (e: any) {
+            console.error('Error creating entity: ', e);
+            throw e;
+          }
+
+          // Start a transaction that ultimately gets committed.
+          const tnymphA = await tnymphTop.startTransaction('steve-a');
+          const EmployeeA = tnymphA.getEntityClass(EmployeeModel);
+          const goodSteve = await EmployeeA.factory();
+          goodSteve.name = 'Steve Complex';
+          goodSteve.current = true;
+          goodSteve.salary = 8000000;
+          goodSteve.startDate = Date.now();
+          goodSteve.subordinates = [];
+          goodSteve.title = 'Seniorer Person';
+          try {
+            await goodSteve.$save();
+            guid = goodSteve.guid as string;
+            await new Promise<void>((res) => setTimeout(res, 200));
+            await tnymphA.commit('steve-a');
+            await new Promise<void>((res) => setTimeout(res, 400));
+            committed = true;
+            await tnymphTop.commit('steve-top');
+          } catch (e: any) {
+            console.error('Error creating entity: ', e);
+            throw e;
+          }
+        }
+      });
+    });
+  });
+
   it('notified of entity update', async () => {
     let jane = await createJane();
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       let mdate = 0;
       if (jane.guid == null) {
         throw new Error('Entity is null.');
@@ -132,13 +315,13 @@ describe('Nymph REST Server and Client', () => {
         {
           type: '&',
           guid: jane.guid,
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
         if (mdate > 0 && (entities[0]?.mdate ?? -1) === mdate) {
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         } else if (Array.isArray(update)) {
           expect(update.length).toEqual(1);
           expect(entities[0].salary).toEqual(8000000);
@@ -157,7 +340,7 @@ describe('Nymph REST Server and Client', () => {
     let [jane, john] = await createBossJane();
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       let mdate = 0;
       if (jane.guid == null || john.guid == null) {
         throw new Error('Entity is null.');
@@ -170,13 +353,13 @@ describe('Nymph REST Server and Client', () => {
             'subordinates',
             [{ class: Employee }, { type: '&', guid: john.guid }],
           ],
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
         if (mdate > 0 && (entities[0]?.mdate ?? -1) === mdate) {
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         } else if (Array.isArray(update)) {
           expect(update.length).toEqual(1);
           expect(entities[0].salary).toEqual(8000000);
@@ -195,44 +378,150 @@ describe('Nymph REST Server and Client', () => {
     let [jane, john] = await createBossJane();
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
-    await new Promise((resolve) => {
-      if (jane.guid == null || john.guid == null) {
-        throw new Error('Entity is null.');
-      }
-      const subscription = pubsub.subscribeEntities(
-        { class: Employee },
-        {
-          type: '&',
-          guid: jane.guid,
-          qref: [
-            'subordinates',
-            [{ class: Employee }, { type: '&', '!truthy': 'current' }],
-          ],
+    // Create employees that matches qref to test when multiple things match.
+    let oldEmployee = await createJane();
+    oldEmployee.current = false;
+    await oldEmployee.$save();
+    let oldEmployee2 = await createJane();
+    oldEmployee2.current = false;
+    await oldEmployee2.$save();
+
+    expect(
+      await new Promise<boolean>((resolve) => {
+        if (jane.guid == null || john.guid == null) {
+          throw new Error('Entity is null.');
         }
-      )(async (update) => {
-        pubsub.updateArray(entities, update);
+        const subscription = pubsub.subscribeEntities(
+          { class: Employee },
+          {
+            type: '&',
+            guid: jane.guid,
+            qref: [
+              'subordinates',
+              [{ class: Employee }, { type: '&', '!truthy': 'current' }],
+            ],
+          },
+        )(async (update) => {
+          pubsub.updateArray(entities, update);
+
+          if (entities.length) {
+            subscription.unsubscribe();
+            resolve(true);
+          } else if (Array.isArray(update)) {
+            expect(update.length).toEqual(0);
 
-        if (entities.length) {
-          subscription.unsubscribe();
-          resolve(true);
-        } else if (Array.isArray(update)) {
-          expect(update.length).toEqual(0);
+            // John gets fired.
+            john.current = false;
+            await john.$save();
+          }
+        });
+      }),
+    ).toEqual(true);
 
-          // John gets fired.
-          john.current = false;
-          await john.$save();
+    expect(entities.length).toEqual(1);
+  });
+
+  it('notified of new match for qref query in transaction', async () => {
+    let entities: (EmployeeClass & EmployeeData)[] = [];
+
+    const john = await EmployeeModel.factory();
+    john.name = 'John Der';
+    john.current = true;
+    john.salary = 8000000;
+    john.startDate = Date.now();
+    john.subordinates = [];
+    john.title = 'Junior Person';
+    try {
+      await john.$save();
+    } catch (e: any) {
+      console.error('Error creating entity: ', e);
+      throw e;
+    }
+
+    const jane = await EmployeeModel.factory();
+    jane.name = 'Jane Doe';
+    jane.current = true;
+    jane.salary = 8000000;
+    jane.startDate = Date.now();
+    jane.subordinates = [john];
+    jane.title = 'Seniorer Person';
+    try {
+      await jane.$save();
+    } catch (e: any) {
+      console.error('Error creating entity: ', e);
+      throw e;
+    }
+
+    async function createNewBoss() {
+      // Create employee that matches qref.
+      const tnymph = await nymphServer.startTransaction('qref-test');
+      const tnymphDeep = await tnymph.startTransaction('qref-deep-test');
+
+      const TEmployeeModel = tnymph.getEntityClass(EmployeeModel);
+      const newBoss = await TEmployeeModel.factory();
+      newBoss.name = 'Jill Doe';
+      newBoss.current = false;
+      newBoss.salary = 8000000;
+      newBoss.startDate = Date.now();
+      newBoss.subordinates = [john];
+      newBoss.title = 'Seniorer Person';
+      try {
+        await newBoss.$save();
+      } catch (e: any) {
+        console.error('Error creating entity: ', e);
+        throw e;
+      }
+
+      newBoss.current = true;
+      try {
+        await newBoss.$save();
+      } catch (e: any) {
+        console.error('Error creating entity: ', e);
+        throw e;
+      }
+
+      await tnymphDeep.commit('qref-deep-test');
+      await tnymph.commit('qref-test');
+    }
+
+    expect(
+      await new Promise<boolean>((resolve) => {
+        if (jane.guid == null || john.guid == null) {
+          throw new Error('Entity is null.');
         }
-      });
-    });
+        const subscription = pubsub.subscribeEntities(
+          { class: Employee },
+          {
+            type: '&',
+            truthy: 'current',
+            qref: [
+              'subordinates',
+              [{ class: Employee }, { type: '&', guid: john.guid }],
+            ],
+          },
+        )(async (update) => {
+          pubsub.updateArray(entities, update);
+
+          if (Array.isArray(update)) {
+            expect(entities.length).toEqual(1);
+            await createNewBoss();
+          } else {
+            expect(entities.length).toEqual(2);
+            subscription.unsubscribe();
+            resolve(true);
+          }
+        });
+      }),
+    ).toEqual(true);
 
-    expect(entities.length).toEqual(1);
+    expect(entities.length).toEqual(2);
   });
 
   it('notified of removed match for qref query', async () => {
     let [jane, john] = await createBossJane();
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       if (jane.guid == null || john.guid == null) {
         throw new Error('Entity is null.');
       }
@@ -245,13 +534,13 @@ describe('Nymph REST Server and Client', () => {
             'subordinates',
             [{ class: Employee }, { type: '&', truthy: 'current' }],
           ],
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
         if (!entities.length) {
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         } else if (Array.isArray(update)) {
           expect(update.length).toEqual(1);
 
@@ -270,9 +559,9 @@ describe('Nymph REST Server and Client', () => {
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
     // Wait for change to propagate. (Only needed since we're not going across network.)
-    await new Promise((resolve) => setTimeout(() => resolve(true), 10));
+    await new Promise<void>((resolve) => setTimeout(() => resolve(), 10));
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       // Should only receive 1 update, since we waited.
       let updated = false;
       if (jane.guid == null) {
@@ -283,13 +572,13 @@ describe('Nymph REST Server and Client', () => {
         {
           type: '&',
           guid: jane.guid,
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
         if (updated) {
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         } else if (Array.isArray(update)) {
           expect(update.length).toEqual(1);
           expect(entities[0].salary).toEqual(8000000);
@@ -305,40 +594,36 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('notified of entity delete', async () => {
-    let jane = await createJane();
+    let jane: EmployeeClass & EmployeeData;
     let entities: (EmployeeClass & EmployeeData)[] = [];
 
-    // Wait for change to propagate. (Only needed since we're not going across network.)
-    await new Promise((resolve) => setTimeout(() => resolve(true), 10));
-
-    let length: number = -1;
-    await new Promise((resolve) => {
-      let updated = false;
-      if (jane.guid == null) {
-        throw new Error('Entity is null.');
-      }
+    let removed = false;
+    await new Promise<void>((resolve) => {
       const subscription = pubsub.subscribeEntities(
         { class: Employee },
         {
           type: '&',
           equal: ['name', 'Jane Doe'],
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
-        if (updated) {
+        if (Array.isArray(update)) {
+          jane = await createJane();
+          if (jane.guid == null) {
+            throw new Error('Entity is null.');
+          }
+        } else if ('added' in update) {
+          await entities.find((e) => e.guid === update.added)?.$delete();
+        } else if ('removed' in update && update.removed === jane.guid) {
           subscription.unsubscribe();
-          resolve(true);
-        } else if (Array.isArray(update)) {
-          expect(update.length).toBeGreaterThan(0);
-          updated = true;
-          length = update.length;
-          await jane.$delete();
+          removed = true;
+          resolve();
         }
       });
     });
 
-    expect(entities.length).toEqual(length - 1);
+    expect(removed).toBeTruthy();
   });
 
   it('entire match is updated', async () => {
@@ -347,9 +632,9 @@ describe('Nymph REST Server and Client', () => {
     await createJane();
 
     // Wait for change to propagate. (Only needed since we're not going across network.)
-    await new Promise((resolve) => setTimeout(() => resolve(true), 10));
+    await new Promise<void>((resolve) => setTimeout(() => resolve(), 10));
 
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       let receivedRemove = false;
       let receivedAdd = false;
       const subscription = pubsub.subscribeEntities(
@@ -357,20 +642,26 @@ describe('Nymph REST Server and Client', () => {
         {
           type: '&',
           equal: ['name', 'Jane Doe'],
-        }
+        },
       )(async (update) => {
         pubsub.updateArray(entities, update);
 
         if (jane) {
-          if ('removed' in update) {
-            receivedRemove = true;
-          }
-          if ('added' in update) {
-            receivedAdd = true;
-          }
-          if (receivedAdd && receivedRemove) {
-            subscription.unsubscribe();
-            resolve(true);
+          const updates =
+            'multiple' in update && update.multiple
+              ? update.messages
+              : [update];
+          for (let curUpdate of updates) {
+            if ('removed' in curUpdate) {
+              receivedRemove = true;
+            }
+            if ('added' in curUpdate) {
+              receivedAdd = true;
+            }
+            if (receivedAdd && receivedRemove) {
+              subscription.unsubscribe();
+              resolve();
+            }
           }
         } else if (Array.isArray(update)) {
           expect(update.length).toEqual(1);
@@ -386,12 +677,13 @@ describe('Nymph REST Server and Client', () => {
   it('entity subscription is updated', async () => {
     let jane = await createJane();
 
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       let mdate = 0;
       const subscription = pubsub.subscribeWith(jane, async () => {
+        expect(jane.guid).not.toBeNull();
         if (mdate > 0 && (jane.mdate ?? -1) === mdate) {
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         }
       });
 
@@ -411,17 +703,84 @@ describe('Nymph REST Server and Client', () => {
     expect(jane.salary).toEqual(9000000);
   });
 
+  it("doesn't allow subscription of a restricted entity class", async () => {
+    let receivedBadUpdate = false;
+    let error = null;
+
+    await new Promise<void>((resolve) => {
+      pubsub.subscribeEntities(
+        { class: Restricted },
+        {
+          type: '&',
+          equal: ['name', 'Jane Doe'],
+        },
+      )(
+        async () => {
+          receivedBadUpdate = true;
+          resolve();
+        },
+        (e: any) => {
+          error = e;
+          resolve();
+        },
+      );
+    });
+
+    expect(receivedBadUpdate).toEqual(false);
+    expect(error).toEqual('Not accessible.');
+  });
+
+  it("doesn't notify of new pubsub disabled entity class", async () => {
+    let receivedBadUpdate = false;
+
+    await new Promise<void>(async (resolve) => {
+      const subscription = await new Promise<
+        PubSubSubscription<
+          PubSubUpdate<(PubSubDisabledClass & PubSubDisabledData)[]>
+        >
+      >(async (resolve) => {
+        let updated = false;
+        const subscription = pubsub.subscribeEntities({
+          class: PubSubDisabled,
+        })(async (update) => {
+          if (updated) {
+            receivedBadUpdate = true;
+          } else {
+            expect(update).toEqual([]);
+            updated = true;
+            try {
+              const entity = await PubSubDisabled.factory();
+              entity.name = 'Someone';
+              if (!(await entity.$save())) {
+                throw new Error("Couldn't save.");
+              }
+              resolve(subscription);
+            } catch (e: any) {
+              console.error('Error creating entity: ', e);
+              throw e;
+            }
+          }
+        });
+      });
+      await new Promise<void>((resolve) => setTimeout(resolve, 200));
+      subscription.unsubscribe();
+      resolve();
+    });
+
+    expect(receivedBadUpdate).toEqual(false);
+  });
+
   it('new uid', async () => {
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       const subscription = pubsub.subscribeUID('testNewUID')(
         async (value) => {
           expect(value).toEqual(directValue);
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
 
       const directValue = await nymph.newUID('testNewUID');
@@ -429,7 +788,7 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('increasing uids', async () => {
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       let receivedFirst = false;
       let lastUpdate: number = 0;
       const subscription = pubsub.subscribeUID('testIncUID')(
@@ -444,12 +803,12 @@ describe('Nymph REST Server and Client', () => {
           lastUpdate = value;
           if (value == 100) {
             subscription.unsubscribe();
-            resolve(true);
+            resolve();
           }
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
 
       await nymph.deleteUID('testIncUID');
@@ -462,16 +821,16 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('set uid', async () => {
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       const subscription = pubsub.subscribeUID('testSetUID')(
         async (value) => {
           expect(value).toEqual(123);
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
 
       await nymph.setUID('testSetUID', 123);
@@ -479,7 +838,7 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('rename uid from old name', async () => {
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       let updated = false;
       const subscription = pubsub.subscribeUID('testRenameUID')(
         async (value, event) => {
@@ -487,15 +846,15 @@ describe('Nymph REST Server and Client', () => {
             expect(event).toEqual('renameUID');
             expect(value).toEqual(null);
             subscription.unsubscribe();
-            resolve(true);
-          } else {
+            resolve();
+          } else if (event === 'setUID') {
             expect(value).toEqual(456);
             updated = true;
           }
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
 
       await nymph.setUID('testRenameUID', 456);
@@ -504,17 +863,17 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('rename uid from new name', async () => {
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       const subscription = pubsub.subscribeUID('newRename2UID')(
         async (value, event) => {
           expect(event).toEqual('setUID');
           expect(value).toEqual(456);
           subscription.unsubscribe();
-          resolve(true);
+          resolve();
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
 
       await nymph.setUID('testRename2UID', 456);
@@ -525,38 +884,51 @@ describe('Nymph REST Server and Client', () => {
   it('delete uid', async () => {
     await nymph.setUID('testDeleteUID', 789);
 
-    await new Promise(async (resolve) => {
+    await new Promise<void>(async (resolve) => {
       let updated = false;
       const subscription = pubsub.subscribeUID('testDeleteUID')(
         async (value, event) => {
           if (updated && event === 'deleteUID') {
             expect(value).toEqual(null);
             subscription.unsubscribe();
-            resolve(true);
+            resolve();
           } else {
             expect(value).toEqual(789);
             updated = true;
+            await nymph.deleteUID('testDeleteUID');
           }
         },
         (err) => {
           expect(err.status).toEqual(404);
-        }
+        },
       );
-
-      await nymph.deleteUID('testDeleteUID');
     });
   });
 
+  beforeEach(async () => {
+    pubsub.connect();
+    while (!pubsub.isConnectionOpen()) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 20));
+    }
+  });
+
   afterAll(async () => {
-    // avoid jest open handle error
-    const closed = new Promise((resolve) => {
+    // Don't publish anything after the tests.
+    removePublisher();
+
+    // Avoid jest open handle errors.
+    const closed = new Promise<void>((resolve) => {
       pubsub.on('disconnect', () => {
-        resolve(true);
+        resolve();
       });
     });
     pubsub.close(); // close PubSub client.
     await closed;
     pubsubServer.close(); // close PubSub server.
     server.close(); // close REST server.
+
+    // Wait for the next event loop to prevent websocket importing something
+    // after jest teardown.
+    await new Promise((resolve) => setImmediate(resolve));
   });
 });