@sockethub/server 5.0.0-alpha.3 → 5.0.0-alpha.4

package/src/bootstrap/init.d.ts

@@ -1,8 +1,18 @@
-declare const init: {
-    version: any;
-    platforms: Map<any, any>;
-    host: any;
-    port: any;
-    path: any;
-};
+export interface IInitObject {
+    version: string;
+    platforms: Map<string, {
+        id: string;
+        moduleName: string;
+        config: {
+            persist?: boolean;
+        };
+        schemas: {
+            credentials?: object;
+            messages?: object;
+        };
+        version: string;
+        types: Array<string>;
+    }>;
+}
+declare const init: IInitObject;
 export default init;

package/src/bootstrap/init.ts

@@ -6,6 +6,7 @@ import platformLoad from './platforms';
 const log = debug('sockethub:server:bootstrap:init');
 log('running init routines');
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageJSON = require('./../../package.json');
 const platforms = platformLoad(config.get('platforms'));
 
@@ -40,7 +41,7 @@ if (config.get('info')) {
   console.log('platforms: ' + Array.from(platforms.keys()).join(', '));
 
   if (platforms.size > 0) {
-    for (let platform of platforms.values()) {
+    for (const platform of platforms.values()) {
       console.log();
       // eslint-disable-next-line security-node/detect-crlf
       console.log(platform.moduleName);

package/src/config.ts

@@ -4,6 +4,13 @@ import * as fs from "fs";
 
 const log = debug('sockethub:server:bootstrap:config');
 
+export type ActivityStreamConfigOptions = {
+  warnOnUnknownObjectProperties?: boolean;
+  failOnUnknownObjectProperties?: boolean;
+  specialObjs?: object;
+  customProps?: object;
+}
+
 export class Config {
   constructor() {
     log('initializing config');
@@ -58,6 +65,7 @@ export class Config {
     nconf.set('examples:enabled', (examples ? true : nconf.get('examples:enabled')));
 
     // load defaults
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const defaults: object = require(__dirname + '/defaults.json');
     nconf.defaults(defaults);
 
@@ -87,7 +95,7 @@ export class Config {
       nconf.clear('redis:port');
     }
   }
-  get = (key: string): any => nconf.get(key);
+  get = (key: string): unknown => nconf.get(key);
 }
 
 const config = new Config();

package/src/index.ts

@@ -1,4 +1,5 @@
-const Sockethub = require('./sockethub').default;
+import Sockethub from "./sockethub";
+
 const sockethub = new Sockethub();
 
 module.exports = async () => {
@@ -21,7 +22,7 @@ module.exports = async () => {
 
   process.once('exit', async function () {
     console.log('destroying all platform instances');
-    await sockethub.removeAllPlatformInstances();
+    await sockethub.shutdown();
   });
 
   sockethub.boot();

package/src/janitor.test.ts

@@ -0,0 +1,189 @@
+import proxyquire from 'proxyquire';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+let sockets = [
+  { id: 'socket foo', emit: () => {} },
+  { id: 'socket bar', emit: () => {} }
+]
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+function getPlatformInstanceFake() {
+  return {
+    flaggedForTermination: false,
+    initialized: false,
+    global: false,
+    shutdown: sinon.stub(),
+    process: {
+      removeListener: sinon.stub()
+    },
+    sessions: new Set(['session foo', 'session bar']),
+    sessionCallbacks: {
+      'close': (() => new Map([
+        ['session foo', function sessionFooClose() {}],
+        ['session bar', function sessionBarClose() {}]
+      ]))(),
+      'message': (() => new Map([
+        ['session foo', function sessionFooMessage() {}],
+        ['session bar', function sessionBarMessage() {}]
+      ]))()
+    }
+  }
+}
+
+const cycleInterval = 10;
+
+describe('Janitor', () => {
+  let sandbox, fetchSocketsFake, janitor;
+
+  beforeEach(function (done) {
+    this.timeout(3000);
+    sandbox = sinon.createSandbox();
+    fetchSocketsFake = sandbox.stub().returns(sockets);
+    const janitorMod = proxyquire('./janitor', {
+      listener: {
+        io: {
+          fetchSockets: fetchSocketsFake
+        }
+      }
+    });
+    janitor = janitorMod.default;
+    janitor.getSockets = fetchSocketsFake;
+    expect(janitor.cycleInterval).to.not.equal(cycleInterval);
+    janitor.cycleInterval = cycleInterval;
+    expect(janitor.cycleInterval).to.equal(cycleInterval);
+    janitor.start();
+    setTimeout(() => {
+      expect(janitor.cycleCount).to.equal(1);
+      done();
+    }, cycleInterval)
+  });
+
+  afterEach((done) => {
+    sandbox.reset();
+    janitor.stop();
+    setTimeout(() => {
+      done();
+    }, janitor.cycleInterval * 2)
+  });
+
+  it('runs cycle at every cycleInterval', (done) => {
+    const currCycleCount = janitor.cycleCount;
+    expect(currCycleCount).to.not.equal(0);
+    setTimeout(() => {
+      expect(janitor.cycleCount).to.equal(currCycleCount + 1);
+      setTimeout(() => {
+        expect(janitor.cycleCount).to.equal(currCycleCount + 2);
+        done();
+      }, cycleInterval);
+    }, cycleInterval);
+  });
+
+  describe('removeSessionCallbacks', () => {
+    it('removes session listeners and callbacks for a given platform', () => {
+      const pi = getPlatformInstanceFake();
+      const barMessage = pi.sessionCallbacks.message.get('session bar');
+      const barClose = pi.sessionCallbacks.close.get('session bar');
+      pi.flaggedForTermination = true;
+      janitor.removeSessionCallbacks(pi, 'session foo');
+      sinon.assert.calledTwice(pi.process.removeListener);
+      expect(pi.sessionCallbacks.message.get('session foo')).to.be.undefined;
+      expect(pi.sessionCallbacks.message.get('session bar')).to.equal(barMessage);
+      expect(pi.sessionCallbacks.close.get('session foo')).to.be.undefined;
+      expect(pi.sessionCallbacks.close.get('session bar')).to.equal(barClose);
+    });
+  });
+
+  describe('removeStaleSocketSessions', () => {
+    it('doesnt do anything if the socket is active and stop is not flagged', async () => {
+      const pi = getPlatformInstanceFake();
+      janitor.removeSessionCallbacks = sinon.stub();
+      janitor.socketExists = sinon.stub().returns(true);
+      expect(janitor.stopTriggered).to.be.false;
+      await janitor.removeStaleSocketSessions(pi);
+      sinon.assert.notCalled(janitor.removeSessionCallbacks);
+    });
+
+    it('removes session if the socket is active and stop is flagged', async () => {
+      const pi = getPlatformInstanceFake();
+      janitor.removeSessionCallbacks = sinon.stub();
+      janitor.socketExists = sinon.stub().returns(true);
+      janitor.stop();
+      expect(janitor.stopTriggered).to.be.true;
+      await janitor.removeStaleSocketSessions(pi);
+      sinon.assert.calledTwice(janitor.removeSessionCallbacks);
+      sinon.assert.calledWith(janitor.removeSessionCallbacks, pi, 'session foo');
+      sinon.assert.calledWith(janitor.removeSessionCallbacks, pi, 'session bar');
+    });
+
+    it('removes session if the socket is inactive', async () => {
+      const pi = getPlatformInstanceFake();
+      janitor.removeSessionCallbacks = sinon.stub();
+      janitor.socketExists = sinon.stub().onFirstCall().returns(false).onSecondCall().returns(true);
+      expect(janitor.stopTriggered).to.be.false;
+      await janitor.removeStaleSocketSessions(pi);
+      sinon.assert.calledOnce(janitor.removeSessionCallbacks);
+      sinon.assert.calledWith(janitor.removeSessionCallbacks, pi, 'session foo');
+    });
+  });
+
+  describe('performStaleCheck', () => {
+    it('removes flagged and uninitialized platform instances', async () => {
+      const pi = getPlatformInstanceFake();
+      pi.flaggedForTermination = true;
+      pi.initialized = false;
+      janitor.removeStaleSocketSessions = sandbox.stub();
+      janitor.removeStalePlatformInstance = sandbox.stub();
+      await janitor.performStaleCheck(pi);
+      sinon.assert.calledOnce(janitor.removeStaleSocketSessions);
+      sinon.assert.calledOnce(janitor.removeStalePlatformInstance);
+      expect(pi.flaggedForTermination).to.be.true;
+    });
+
+    it('flags for termination when there are not sockets', async () => {
+      const pi = getPlatformInstanceFake();
+      pi.sessions = new Set();
+      pi.flaggedForTermination = false;
+      pi.initialized = true;
+      janitor.removeStaleSocketSessions = sandbox.stub();
+      janitor.removeStalePlatformInstance = sandbox.stub();
+      await janitor.performStaleCheck(pi);
+      sinon.assert.calledOnce(janitor.removeStaleSocketSessions);
+      sinon.assert.calledOnce(janitor.removeStalePlatformInstance);
+    });
+  });
+
+  describe('removeStalePlatformInstance', () => {
+    it('flags stale platform', async () => {
+      const pi = getPlatformInstanceFake();
+      expect(pi.flaggedForTermination).to.be.false;
+      await janitor.removeStalePlatformInstance(pi);
+      sinon.assert.notCalled(pi.shutdown);
+      expect(pi.flaggedForTermination).to.be.true;
+    });
+
+    it('removes flagged stale platform', async () => {
+      const pi = getPlatformInstanceFake();
+      pi.flaggedForTermination = true;
+      await janitor.removeStalePlatformInstance(pi);
+      sinon.assert.calledOnce(pi.shutdown);
+    });
+  });
+
+  it('closes all connections when stop() is called', (done) => {
+    const prevCycle = janitor.cycleCount;
+    janitor.stop();
+    setTimeout(() => {
+      expect(janitor.cycleCount).to.equal(prevCycle);
+      setTimeout(() => {
+        expect(janitor.cycleCount).to.equal(prevCycle);
+        setTimeout(() => {
+          expect(janitor.cycleCount).to.equal(prevCycle);
+          done();
+        }, cycleInterval)
+      }, cycleInterval)
+    }, cycleInterval);
+  });
+})

package/src/janitor.ts

@@ -5,85 +5,130 @@ import listener, { SocketInstance } from "./listener";
 
 const rmLog = debug('sockethub:server:janitor');
 
-const TICK = 15000;
-let alreadyCalled: boolean = false;
-let cycleCount: number = 0;   // a counter for each setInterval call
-let reportCount: number = 0;  // number of times a report is printed
-
-/**
- * Every TICK the Janitor will compare existing platform instances with socket.ids (aka. sessionId)
- * If all of the sessionIds associated with a platformInstance have no corresponding socket.id
- * (from the http.io socket.io instance), then the platformInstance will first be flagged, if after
- * the next TICK the same state is determined, the platform will be destroyed (this allows for page
- * refreshes not destroying platform instances)
- */
-function janitorCycle() {
-  if (! alreadyCalled) { alreadyCalled = true; }
-  else { return; }
-  rmLog('initializing resource manager');
-  setInterval(async () => {
-    cycleCount++;
-    const sockets: Array<SocketInstance> = await listener.io.fetchSockets();
-
-    if (! (cycleCount % 4)) {
-      reportCount++;
-      rmLog(`socket sessions: ${sockets.length} platform instances: ${platformInstances.size}`);
+class Janitor {
+  cycleInterval = 15000;
+  cycleCount = 0;   // a counter for each cycleInterval
+  reportCount = 0;  // number of times a report is printed
+  protected stopTriggered = false;
+  protected sockets: Array<SocketInstance>;
+  private cycleRunning = false;
+
+  /**
+   * Every TICK the `Janitor` will compare existing platform instances with `socket.ids`
+   * (aka. `sessionId`). If all of the `sessionIds` associated with a `platformInstance` have
+   * no corresponding `socket.id` (from the `http.io` `socket.io` instance), then the
+   * `platformInstance` will first be flagged, if after the next `cycleInterval` the same
+   * state is determined, the platform will be destroyed (this allows for page
+   * refreshes not destroying platform instances)
+   */
+  start(): void {
+    rmLog('initializing');
+    this.clean().then(() => {
+      rmLog('cleaning cycle started');
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.stopTriggered = true;
+    rmLog('stopping, terminating all sessions');
+    for (const platformInstance of platformInstances.values()) {
+      this.removeStaleSocketSessions(platformInstance);
+      await this.removeStalePlatformInstance(platformInstance);
+      await platformInstance.shutdown();
     }
+  }
+
+  private removeSessionCallbacks(platformInstance: PlatformInstance, sessionId: string): void {
+    for (const key in platformInstance.sessionCallbacks) {
+      platformInstance.process.removeListener(
+        key, platformInstance.sessionCallbacks[key].get(sessionId));
+      platformInstance.sessionCallbacks[key].delete(sessionId);
+    }
+  }
 
-    for (let platformInstance of platformInstances.values()) {
-      removeStaleSocketSessions(platformInstance, sockets);
-      // Static platforms are for global use, not tied to a unique to session / eg. credentials)
-      if ((! platformInstance.global) && (platformInstance.sessions.size === 0)) {
-        removeStalePlatformInstance(platformInstance);
-      } else {
-        platformInstance.flaggedForTermination = false;
+  private removeStaleSocketSessions(
+    platformInstance: PlatformInstance
+  ): void {
+    for (const sessionId of platformInstance.sessions.values()) {
+      if ((this.stopTriggered) || (!this.socketExists(sessionId))) {
+        this.removeStaleSocketSession(platformInstance, sessionId);
       }
     }
-  }, TICK);
-}
+  }
+
+  private removeStaleSocketSession(platformInstance: PlatformInstance, sessionId: string) {
+    rmLog(
+      `removing ${!this.stopTriggered ? 'stale ' : ''}socket session reference ${sessionId} 
+          in platform instance ${platformInstance.id}`
+    );
+    platformInstance.sessions.delete(sessionId);
+    this.removeSessionCallbacks(platformInstance, sessionId);
+  }
 
-function socketExists(sessionId: string, sockets: Array<SocketInstance>) {
-  for (let socket of sockets) {
-    if (socket.id === sessionId) {
-      return true;
+  private async removeStalePlatformInstance(platformInstance: PlatformInstance): Promise<void> {
+    if ((platformInstance.flaggedForTermination) || (this.stopTriggered)) {
+      rmLog(`terminating platform instance ${platformInstance.id}`);
+      await platformInstance.shutdown(); // terminate
+    } else {
+      rmLog(`flagging for termination platform instance ${platformInstance.id} ` +
+        `(no registered sessions found)`);
+      platformInstance.flaggedForTermination = true;
     }
   }
-  return false;
-}
 
-function removeSessionCallbacks(platformInstance: PlatformInstance, sessionId: string) {
-  for (const key in platformInstance.sessionCallbacks) {
-    platformInstance.sessionCallbacks[key].delete(sessionId);
+  private socketExists(sessionId: string) {
+    for (const socket of this.sockets) {
+      if (socket.id === sessionId) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private async delay(ms): Promise<void> {
+    return await new Promise(resolve => setTimeout(resolve, ms));
   }
-}
 
-function removeStaleSocketSessions(platformInstance: PlatformInstance,
-                                   sockets: Array<SocketInstance>) {
-  for (const sessionId of platformInstance.sessions.values()) {
-    if (! socketExists(sessionId, sockets)) {
-      rmLog('removing stale socket session reference ' + sessionId + ' in platform instance '
-        + platformInstance.id);
-      platformInstance.sessions.delete(sessionId);
-      removeSessionCallbacks(platformInstance, sessionId);
+  private async getSockets(): Promise<Array<SocketInstance>> {
+    return await listener.io.fetchSockets();
+  }
+
+  private async performStaleCheck(platformInstance: PlatformInstance) {
+    this.removeStaleSocketSessions(platformInstance);
+    // Static platforms are for global use, not tied to a unique to session / eg. credentials)
+    if (!platformInstance.global) {
+      if ((!platformInstance.initialized) || (platformInstance.sessions.size === 0)) {
+        // either the platform failed to initialize, or there are no more sessions linked to it
+        await this.removeStalePlatformInstance(platformInstance);
+      }
     }
   }
-}
 
-function removeStalePlatformInstance(platformInstance: PlatformInstance) {
-  if (platformInstance.flaggedForTermination) {
-    rmLog(`terminating platform instance ${platformInstance.id}`);
-    platformInstance.destroy(); // terminate
-  } else {
-    rmLog(`flagging for termination platform instance ${platformInstance.id} ` +
-      `(no registered sessions found)`);
-    platformInstance.flaggedForTermination = true;
+  private async clean(): Promise<void> {
+    if (this.stopTriggered) {
+      this.cycleRunning = false;
+      return;
+    } else if (this.cycleRunning) {
+      throw new Error('janitor cleanup cycle called while already running');
+    }
+    this.cycleRunning = true;
+    this.cycleCount++;
+    this.sockets = await this.getSockets();
+
+    if (!(this.cycleCount % 4)) {
+      this.reportCount++;
+      rmLog(
+        `socket sessions: ${this.sockets.length} platform instances: ${platformInstances.size}`);
+    }
+
+    for (const platformInstance of platformInstances.values()) {
+      await this.performStaleCheck(platformInstance);
+    }
+    this.cycleRunning = false;
+    await this.delay(this.cycleInterval);
+    return this.clean();
   }
 }
 
-const janitor = {
-  clean: janitorCycle,
-  alreadyCalled: alreadyCalled,
-  cycleCount: cycleCount,
-  reportCount: reportCount
-};
+const janitor = new Janitor();
 export default janitor;

package/src/listener.ts

@@ -29,7 +29,7 @@ class Listener {
     const app = Listener.initExpress();
     this.http = new HTTP.Server(app);
     this.io = new Server(this.http, {
-      path: config.get('sockethub:path'),
+      path: config.get('sockethub:path') as string,
       cors: {
         origin: "*",
         methods: [ "GET", "POST" ]
@@ -40,14 +40,14 @@ class Listener {
   }
 
   private startHttp() {
-    this.http.listen(config.get('sockethub:port'), config.get('sockethub:host'), () => {
+    this.http.listen(config.get('sockethub:port'), config.get('sockethub:host') as number, () => {
       log(`sockethub listening on ` +
-        `http://${config.get('sockethub:host')}:${config.get('sockethub:port')}`);
+        `${config.get('sockethub:host')}:${config.get('sockethub:port')}`);
     });
-  };
+  }
 
   private static initExpress() {
-    let app = express();
+    const app = express();
     // templating engines
     app.set('view engine', 'ejs');
     // use bodyParser
@@ -59,15 +59,19 @@ class Listener {
 
 const listener = new Listener();
 
+interface EmitFunction {
+  (type: string, data: unknown)
+}
+
 export interface SocketInstance {
   id: string;
-  emit: Function;
+  emit: EmitFunction;
 }
 
 export async function getSocket(sessionId: string): Promise<SocketInstance> {
   const sockets: Array<SocketInstance> = await listener.io.fetchSockets();
   return new Promise((resolve, reject) => {
-    for (let socket of sockets) {
+    for (const socket of sockets) {
       if (sessionId === socket.id) {
         return resolve(socket);
       }

package/src/middleware/create-activity-object.ts

@@ -1,5 +1,7 @@
 import ActivityStreams from '@sockethub/activity-streams';
 import config from "../config";
+import {IActivityStream} from "@sockethub/schemas";
+import {MiddlewareChainInterface} from "../middleware";
 const activity = ActivityStreams(config.get('activity-streams:opts'));
 
 /**
@@ -7,7 +9,8 @@ const activity = ActivityStreams(config.get('activity-streams:opts'));
  * @param obj
  * @param done
  */
-export default function createActivityObject(obj: any, done: Function) {
+export default function createActivityObject(obj: IActivityStream,
+                                             done: MiddlewareChainInterface) {
   activity.Object.create(obj);
   done(obj);
-}
+}

package/src/middleware/expand-activity-stream.test.data.ts

@@ -68,10 +68,10 @@ export default [
         "image":{
           "height":250,
           "mediaType":"image/jpeg",
-          "url":"http://example.org/image.jpg",
+          "url":"https://example.org/image.jpg",
           "width":250
         },
-        "url":"http://sockethub.org"
+        "url":"https://sockethub.org"
       },
       "object":{
         "type":"credentials",
@@ -340,10 +340,10 @@ export default [
         "image":{
           "height":250,
           "mediaType":"image/jpeg",
-          "url":"http://example.org/image.jpg",
+          "url":"https://example.org/image.jpg",
           "width":250
         },
-        "url":"http://sockethub.org"
+        "url":"https://sockethub.org"
       },
       "target":{
         "id":"blah3",
@@ -362,4 +362,4 @@ export default [
       }
     }
   }
-];
+];

package/src/middleware/expand-activity-stream.test.ts

@@ -30,10 +30,10 @@ const activity = ActivityStreams();
     "image":{
       "height":250,
       "mediaType":"image/jpeg",
-      "url":"http://example.org/image.jpg",
+      "url":"https://example.org/image.jpg",
       "width":250
     },
-    "url":"http://sockethub.org"
+    "url":"https://sockethub.org"
   },
   {
     "id":"blah3",

package/src/middleware/expand-activity-stream.ts

@@ -1,24 +1,29 @@
 import ActivityStreams from '@sockethub/activity-streams';
-import { IActivityStream } from "@sockethub/schemas";
+import {IActivityStream} from "@sockethub/schemas";
 
-import config from "../config";
+import config, {ActivityStreamConfigOptions} from "../config";
+import {MiddlewareChainInterface} from "../middleware";
 
-const activity = ActivityStreams(config.get('activity-streams:opts'));
+const asConfig = config.get('activity-streams:opts') as ActivityStreamConfigOptions;
+asConfig.warnOnUnknownObjectProperties = false;
+asConfig.failOnUnknownObjectProperties = false;
+const activity = ActivityStreams(asConfig);
 
-function ensureObject(msg: any) {
+function ensureObject(msg: unknown) {
   return !((typeof msg !== 'object') || (Array.isArray(msg)));
 }
 
-export default function expandActivityStream(msg: IActivityStream, done: Function) {
+export default function expandActivityStream(msg: IActivityStream,
+                                             done: MiddlewareChainInterface) {
   if (! ensureObject(msg)) {
     done(new Error(`message received is not an object.`));
   } else if (typeof msg.context !== 'string') {
     done(new Error('activity stream must contain a context property'));
-  }  else if (typeof msg.type !== 'string') {
+  } else if (typeof msg.type !== 'string') {
     done(new Error('activity stream must contain a type property.'));
   } else {
     msg = activity.Stream(msg);
-    if (! msg.actor) {
+    if (!msg.actor) {
       done(new Error('activity stream must contain an actor property.'));
     } else {
       done(msg);

package/src/middleware/store-credentials.test.ts

@@ -24,7 +24,7 @@ const creds = {
 
 describe('Middleware: storeCredentials', () => {
   let storeSuccess: any, storeError: any, saveErrorFake: any,
-      saveSuccessFake: any, sessionLogStub: any;
+      saveSuccessFake: any;
 
   beforeEach(() => {
     storeSuccess = {
@@ -39,7 +39,6 @@ describe('Middleware: storeCredentials', () => {
     };
     saveSuccessFake = sinon.replace(storeSuccess, 'save', sinon.fake(storeSuccess.save));
     saveErrorFake = sinon.replace(storeError, 'save', sinon.fake(storeError.save));
-    sessionLogStub = sinon.stub();
   });
 
   afterEach(() => {
@@ -47,14 +46,13 @@ describe('Middleware: storeCredentials', () => {
   });
 
   it('returns a middleware handler', () => {
-    const sc = storeCredentials(storeSuccess, sessionLogStub);
+    const sc = storeCredentials(storeSuccess);
     expect(typeof sc).to.equal('function');
     expect(saveSuccessFake.callCount).to.equal(0);
-    expect(sessionLogStub.callCount).to.equal(0);
   });
 
   it('successfully store credentials', () => {
-    const sc = storeCredentials(storeSuccess, sessionLogStub);
+    const sc = storeCredentials(storeSuccess);
     sc(creds, (err: any) => {
       expect(saveSuccessFake.callCount).to.equal(1);
       expect(saveSuccessFake.firstArg).to.equal(creds.actor.id);
@@ -63,7 +61,7 @@ describe('Middleware: storeCredentials', () => {
   });
 
   it('handle error while storing credentials', () => {
-    const sc = storeCredentials(storeError, sessionLogStub);
+    const sc = storeCredentials(storeError);
     sc(creds, (err: any) => {
       expect(saveErrorFake.callCount).to.equal(1);
       expect(saveErrorFake.firstArg).to.equal(creds.actor.id);