last fix

Author: tegefaulkes

src/nodes/NodeConnection.ts

@@ -168,6 +168,7 @@ class NodeConnection<T extends GRPCClient> {
   public async destroy() {
     this.logger.info(`Destroying ${this.constructor.name}`);
     if (
+      this.client != null &&
       this.client[asyncInit.status] !== 'destroying' &&
       !this.client[asyncInit.destroyed]
     ) {

tests/nodes/NodeConnectionManager.termination.test.ts

@@ -7,7 +7,7 @@ import path from 'path';
 import os from 'os';
 import { DB } from '@matrixai/db';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
-import { _destroyed } from '@matrixai/async-init/dist/utils';
+import { destroyed } from '@matrixai/async-init/';
 import { IdInternal } from '@matrixai/id';
 import PolykeyAgent from '@/PolykeyAgent';
 import KeyManager from '@/keys/KeyManager';
@@ -402,7 +402,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();
@@ -452,11 +452,11 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
         agentNodeId,
         async (connection) => {
           const client = connection.getClient();
-          expect(connection[_destroyed]).toBe(false);
-          expect(client[_destroyed]).toBe(false);
+          expect(connection[destroyed]).toBe(false);
+          expect(client[destroyed]).toBe(false);
           await polykeyAgent?.stop();
-          expect(client[_destroyed]).toBe(true);
-          expect(connection[_destroyed]).toBe(true);
+          expect(client[destroyed]).toBe(true);
+          expect(connection[destroyed]).toBe(true);
           // Breaking call
           const attemptP = client.echo(new utilsPB.EchoMessage());
           await expect(attemptP).rejects.toThrow();
@@ -473,7 +473,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();
@@ -547,7 +547,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();
@@ -621,7 +621,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();
@@ -670,19 +670,18 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       // Resolves if the shutdownCallback was called
       await nodeConnectionManager.withConnF(agentNodeId, async (connection) => {
         const client = connection.getClient();
-        expect(connection[_destroyed]).toBe(false);
-        expect(client[_destroyed]).toBe(false);
+        expect(connection[destroyed]).toBe(false);
+        expect(client[destroyed]).toBe(false);
 
         // We want to watch for the killSelf event by hijacking the NodeConnectionmanagerInterface
         const oldKillSelf =
-          // @ts-ignore: kidnap the interface
-          connection.nodeConnectionManagerInterface.destroyCallback;
-        // @ts-ignore: update the interface;
-        connection.nodeConnectionManagerInterface.destroyCallback =
-          async () => {
-            await oldKillSelf();
-            killSelfP.resolveP(null);
-          };
+          // @ts-ignore: kidnap the callback
+          connection.destroyCallback;
+        // @ts-ignore: update the callback;
+        connection.destroyCallback = async () => {
+          await oldKillSelf();
+          killSelfP.resolveP(null);
+        };
         await connection.destroy();
       });
 
@@ -696,7 +695,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();
@@ -743,16 +742,15 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
 
       // We want to watch for the killSelf event by hijacking the NodeConnectionmanagerInterface
       const oldKillSelf =
-        // @ts-ignore: kidnap the interface
-        firstConnection?.nodeConnectionManagerInterface.destroyCallback;
+        // @ts-ignore: kidnap the callback
+        firstConnection?.destroyCallback;
       const killSelfP = promise<null>();
       if (firstConnection != null) {
-        // @ts-ignore: update the interface;
-        firstConnection.nodeConnectionManagerInterface.destroyCallback =
-          async () => {
-            if (oldKillSelf != null) await oldKillSelf();
-            killSelfP.resolveP(null);
-          };
+        // @ts-ignore: update the callback;
+        firstConnection.destroyCallback = async () => {
+          if (oldKillSelf != null) await oldKillSelf();
+          killSelfP.resolveP(null);
+        };
       }
       await firstConnection?.destroy();
       // Wait for `killSelf` to resolve
@@ -765,7 +763,7 @@ describe(`${NodeConnectionManager.name} termination test`, () => {
       );
       expect(connAndLock?.lock.isLocked()).toBe(false);
       if (firstConnection != null) {
-        expect(firstConnection[_destroyed]).toBe(true);
+        expect(firstConnection[destroyed]).toBe(true);
       }
     } finally {
       await nodeConnectionManager?.stop();