Shutdown Doc worker when it is not considered as available in Redis #831 (#856)

* Shutdown Doc worker when it is not considered as available in Redis
* Use isAffirmative for GRIST_MANAGED_WORKERS
* Upgrade Sinon for the tests
* Run Smoke test with pages in English
* Add logic in /status endpoint

test/client/lib/SafeBrowser.ts

@@ -46,7 +46,7 @@ describe('SafeBrowser', function() {
 
     browserProcesses = [];
     sandbox.stub(SafeBrowser, 'createWorker').callsFake(createProcess);
-    sandbox.stub(SafeBrowser, 'createView').callsFake(createProcess);
+    sandbox.stub(SafeBrowser, 'createView').callsFake(createProcess as any);
     sandbox.stub(PluginInstance.prototype, 'getRenderTarget').returns(noop);
     disposeSpy = sandbox.spy(Disposable.prototype, 'dispose');
   });

test/client/lib/dispose.js

@@ -153,9 +153,8 @@ describe('dispose', function() {
       assert.equal(baz.dispose.callCount, 1);
       assert(baz.dispose.calledBefore(bar.dispose));
 
-      const name = consoleErrors[0][1];  // may be Foo, or minified.
-      assert(name === 'Foo' || name === 'o');  // this may not be reliable,
-                                               // just what I happen to see.
+      const name = consoleErrors[0][1];
+      assert(name === Foo.name);
       assert.deepEqual(consoleErrors[0], ['Error constructing %s:', name, 'Error: test-error1']);
       assert.deepEqual(consoleErrors[1], ['Error constructing %s:', name, 'Error: test-error2']);
       assert.deepEqual(consoleErrors[2], ['Error constructing %s:', name, 'Error: test-error3']);

test/gen-server/lib/DocWorkerMap.ts

@@ -0,0 +1,56 @@
+// Test for DocWorkerMap.ts
+
+import { DocWorkerMap } from 'app/gen-server/lib/DocWorkerMap';
+import { DocWorkerInfo } from 'app/server/lib/DocWorkerMap';
+import {expect} from 'chai';
+import sinon from 'sinon';
+
+describe('DocWorkerMap', () => {
+  const sandbox = sinon.createSandbox();
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('isWorkerRegistered', () => {
+    const baseWorkerInfo: DocWorkerInfo = {
+      id: 'workerId',
+      internalUrl: 'internalUrl',
+      publicUrl: 'publicUrl',
+      group: undefined
+    };
+
+    [
+      {
+        itMsg: 'should check if worker is registered',
+        sisMemberAsyncResolves: 1,
+        expectedResult: true,
+        expectedKey: 'workers-available-default'
+      },
+      {
+        itMsg: 'should check if worker is registered in a certain group',
+        sisMemberAsyncResolves: 1,
+        group: 'dummygroup',
+        expectedResult: true,
+        expectedKey: 'workers-available-dummygroup'
+      },
+      {
+        itMsg: 'should return false if worker is not registered',
+        sisMemberAsyncResolves: 0,
+        expectedResult: false,
+        expectedKey: 'workers-available-default'
+      }
+    ].forEach(ctx => {
+      it(ctx.itMsg, async () => {
+        const sismemberAsyncStub = sinon.stub().resolves(ctx.sisMemberAsyncResolves);
+        const stubDocWorkerMap = {
+          _client: { sismemberAsync: sismemberAsyncStub }
+        };
+        const result = await DocWorkerMap.prototype.isWorkerRegistered.call(
+          stubDocWorkerMap, {...baseWorkerInfo, group: ctx.group }
+        );
+        expect(result).to.equal(ctx.expectedResult);
+        expect(sismemberAsyncStub.calledOnceWith(ctx.expectedKey, baseWorkerInfo.id)).to.equal(true);
+      });
+    });
+  });
+});

test/server/Comm.ts

@@ -402,20 +402,19 @@ describe('Comm', function() {
 
       // Intercept the call to _onClose to know when it occurs, since we are trying to hit a
       // situation where 'close' and 'failedSend' events happen in either order.
-      const stubOnClose = sandbox.stub(Client.prototype as any, '_onClose')
-        .callsFake(async function(this: Client) {
-          if (!options.closeHappensFirst) { await delay(10); }
+      const stubOnClose: any = sandbox.stub(Client.prototype as any, '_onClose')
+        .callsFake(function(this: Client) {
           eventsSeen.push('close');
-          return (stubOnClose as any).wrappedMethod.apply(this, arguments);
+          return stubOnClose.wrappedMethod.apply(this, arguments);
         });
 
       // Intercept calls to client.sendMessage(), to know when it fails, and possibly to delay the
       // failures to hit a particular order in which 'close' and 'failedSend' events are seen by
       // Client.ts. This is the only reliable way I found to reproduce this order of events.
-      const stubSendToWebsocket = sandbox.stub(Client.prototype as any, '_sendToWebsocket')
+      const stubSendToWebsocket: any = sandbox.stub(Client.prototype as any, '_sendToWebsocket')
         .callsFake(async function(this: Client) {
           try {
-            return await (stubSendToWebsocket as any).wrappedMethod.apply(this, arguments);
+            return await stubSendToWebsocket.wrappedMethod.apply(this, arguments);
           } catch (err) {
             if (options.closeHappensFirst) { await delay(100); }
             eventsSeen.push('failedSend');

test/server/lib/MinIOExternalStorage.ts

@@ -48,7 +48,7 @@ describe("MinIOExternalStorage", function () {
 
       s3.listObjects.returns(fakeStream);
 
-      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3);
+      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3 as any);
       const result = await extStorage.versions(key);
 
       assert.deepEqual(result, []);
@@ -74,7 +74,7 @@ describe("MinIOExternalStorage", function () {
       ]);
 
       s3.listObjects.returns(fakeStream);
-      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3);
+      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3 as any);
       // when
       const result = await extStorage.versions(key);
       // then
@@ -107,7 +107,7 @@ describe("MinIOExternalStorage", function () {
       let {fakeStream} = makeFakeStream(objectsFromS3);
 
       s3.listObjects.returns(fakeStream);
-      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3);
+      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3 as any);
 
       // when
       const result = await extStorage.versions(key);
@@ -142,10 +142,10 @@ describe("MinIOExternalStorage", function () {
       const fakeStream = new stream.Readable({objectMode: true});
       const error = new Error("dummy-error");
       sandbox.stub(fakeStream, "_read")
-        .returns(fakeStream)
+        .returns(fakeStream as any)
         .callsFake(() => fakeStream.emit('error', error));
       s3.listObjects.returns(fakeStream);
-      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3);
+      const extStorage = new MinIOExternalStorage(dummyBucket, dummyOptions, 42, s3 as any);
 
       // when
       const result = extStorage.versions(key);
@@ -154,4 +154,4 @@ describe("MinIOExternalStorage", function () {
       return assert.isRejected(result, error);
     });
   });
-});
+});