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

package/src/platform-instance.test.ts

@@ -1,237 +1,531 @@
-import proxyquire from 'proxyquire';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
+import { __dirname } from "./util.js";
+const FORK_PATH = __dirname + "/platform.js";
 
-proxyquire.noPreserveCache();
-proxyquire.noCallThru();
-
-const FORK_PATH = __dirname + '/platform.js';
+import PlatformInstance, { platformInstances } from "./platform-instance.js";
 
 describe("PlatformInstance", () => {
-  let pi, sandbox, forkFake, socketMock, getSocketFake, PlatformInstance, platformInstances;
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox();
-    forkFake = sandbox.fake();
-    socketMock = {
-      emit: sandbox.spy()
-    };
-    getSocketFake = sinon.fake.resolves(socketMock);
-
-    const PlatformInstanceMod = proxyquire('./platform-instance', {
-      '@sockethub/data-layer': {
-        JobQueue: sandbox.stub().returns({
-          shutdown: sandbox.stub(),
-          on: sandbox.stub(),
-          getJob: sandbox.stub(),
-          initResultEvents: sandbox.stub()
-        })
-      },
-      'child_process': {
-        fork: forkFake,
-        ChildProcess: sandbox.stub()
-      },
-      './listener': {
-        'io': {
-          'in': sandbox.stub().returns({
-            fetchSockets: () => {
-              return [socketMock];
-            }
-          })
-        },
-        getSocket: getSocketFake
-      }
-    });
-    PlatformInstance = PlatformInstanceMod.default;
-    platformInstances = PlatformInstanceMod.platformInstances;
-  });
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  describe('private instance per-actor', () => {
-    it("is set as non-global when an actor is provided", async () => {
-      const pi = new PlatformInstance({
-        identifier: 'id',
-        platform: 'name',
-        parentId: 'parentId',
-        actor: 'actor string'
-      });
-      expect(pi.global).to.be.equal(false);
-      sandbox.assert.calledWith(forkFake, FORK_PATH, ['parentId', 'name', 'id']);
-      await pi.shutdown();
-    });
-  });
+    let pi, sandbox, forkFake, socketMock, getSocketFake;
 
-  describe('PlatformInstance objects', () => {
     beforeEach(() => {
-      pi = new PlatformInstance({
-        identifier: 'platform identifier',
-        platform: 'a platform name',
-        parentId: 'the parentId'
-      });
-      platformInstances.set(pi.id, pi);
-
-      pi.process = {
-        on: sandbox.spy(),
-        removeListener: sandbox.spy(),
-        removeAllListeners: sandbox.spy(),
-        unref: sandbox.spy(),
-        kill: sandbox.spy(),
-      };
+        sandbox = sinon.createSandbox();
+        socketMock = {
+            emit: sandbox.spy(),
+        };
+        getSocketFake = sinon.fake.resolves(socketMock);
+        forkFake = sandbox.fake();
     });
 
-    afterEach(async () => {
-      await pi.shutdown();
-    });
+    function getTestPlatformInstanceClass() {
+        class TestPlatformInstance extends PlatformInstance {
+            createQueue() {
+                this.JobQueue = sandbox.stub().returns({
+                    shutdown: sandbox.stub(),
+                    on: sandbox.stub(),
+                    getJob: sandbox.stub(),
+                    initResultEvents: sandbox.stub(),
+                });
+            }
 
-    it('has expected properties', () => {
-      expect(typeof PlatformInstance).to.be.equal('function');
-    });
+            initProcess(parentId, name, id, env) {
+                this.process = forkFake(FORK_PATH, [parentId, name, id], env);
+            }
 
-    it('should have a platformInstances Map', () => {
-      expect(platformInstances instanceof Map).to.be.equal(true);
-    });
+            createGetSocket() {
+                this.getSocket = getSocketFake;
+            }
+        }
+        return TestPlatformInstance;
+    }
 
-    it("has certain accessible properties", () => {
-      expect(pi.id).to.be.equal('platform identifier');
-      expect(pi.name).to.be.equal('a platform name');
-      expect(pi.parentId).to.be.equal('the parentId');
-      expect(pi.flaggedForTermination).to.be.equal(false);
-      expect(pi.global).to.be.equal(true);
-      expect(forkFake.calledWith(FORK_PATH, [
-        'the parentId', 'a platform name', 'platform identifier'
-      ])).to.be.ok;
+    afterEach(() => {
+        sinon.restore();
     });
 
-    describe('registerSession', () => {
-      beforeEach(() => {
-        pi.callbackFunction = sandbox.fake();
-      });
-
-      it('adds a close and message handler when a session is registered', () => {
-        pi.registerSession('my session id');
-        expect(pi.callbackFunction.callCount).to.equal(2);
-        sandbox.assert.calledWith(pi.callbackFunction, 'close', 'my session id');
-        sandbox.assert.calledWith(pi.callbackFunction, 'message', 'my session id');
-        expect(pi.sessions.has('my session id')).to.be.equal(true);
-      });
-
-      it('is able to generate failure reports', () => {
-        pi.registerSession('my session id');
-        expect(pi.sessions.has('my session id')).to.be.equal(true);
-        pi.reportError('my session id', 'an error message');
-        pi.sendToClient = sandbox.stub();
-        pi.shutdown = sandbox.stub();
-        expect(pi.sessions.size).to.be.equal(0);
-      });
+    describe("private instance per-actor", () => {
+        it("is set as non-global when an actor is provided", async () => {
+            const TestPlatformInstance = getTestPlatformInstanceClass();
+            const pi = new TestPlatformInstance({
+                identifier: "id",
+                platform: "name",
+                parentId: "parentId",
+                actor: "actor string",
+            });
+            expect(pi.global).toEqual(false);
+            sandbox.assert.calledWith(forkFake, FORK_PATH, [
+                "parentId",
+                "name",
+                "id",
+            ]);
+            await pi.shutdown();
+        });
     });
 
-    it('initializes the job queue', () => {
-      expect(pi.jobQueue).to.be.undefined;
-      pi.initQueue('a secret');
-      expect(pi.jobQueue).to.be.ok;
-    });
+    describe("PlatformInstance objects", () => {
+        beforeEach(() => {
+            const TestPlatformInstance = getTestPlatformInstanceClass();
+            pi = new TestPlatformInstance({
+                identifier: "platform identifier",
+                platform: "a platform name",
+                parentId: "the parentId",
+            });
+            platformInstances.set(pi.id, pi);
 
-    it("cleans up its references when shutdown", async () => {
-      pi.initQueue('a secret');
-      expect(pi.jobQueue).to.be.ok;
-      expect(platformInstances.has('platform identifier')).to.be.true;
-      await pi.shutdown();
-      expect(pi.jobQueue).not.to.be.ok;
-      expect(platformInstances.has('platform identifier')).to.be.false;
-    });
+            pi.process = {
+                on: sandbox.spy(),
+                removeListener: sandbox.spy(),
+                removeAllListeners: sandbox.spy(),
+                unref: sandbox.spy(),
+                kill: sandbox.spy(),
+            };
+        });
 
-    it("updates its identifier when changed", () => {
-      pi.updateIdentifier('foo bar');
-      expect(pi.id).to.be.equal('foo bar');
-      expect(platformInstances.has('platform identifier')).to.be.false;
-      expect(platformInstances.has('foo bar')).to.be.true;
-    });
+        afterEach(async () => {
+            await pi.shutdown();
+        });
 
-    it('sends messages to client using socket session id', async () => {
-      await pi.sendToClient('my session id',
-        {foo: 'this is a message object', sessionSecret: 'private data'});
-      expect(getSocketFake.callCount).to.equal(1);
-      sandbox.assert.calledOnce(getSocketFake);
-      sandbox.assert.calledWith(getSocketFake, 'my session id');
-      sandbox.assert.calledOnce(socketMock.emit);
-      sandbox.assert.calledWith(
-        socketMock.emit, 'message', {foo:'this is a message object', context: 'a platform name'});
-    });
+        it("has expected properties", () => {
+            const TestPlatformInstance = getTestPlatformInstanceClass();
+            expect(typeof TestPlatformInstance).toEqual("function");
+        });
 
-    it('broadcasts to peers', async () => {
-      pi.sessions.add('other peer');
-      pi.sessions.add('another peer');
-      await pi.broadcastToSharedPeers('myself', {foo: 'bar'});
-      expect(getSocketFake.callCount).to.equal(2);
-      sandbox.assert.calledWith(getSocketFake, 'other peer');
-    });
+        it("should have a platformInstances Map", () => {
+            expect(platformInstances instanceof Map).toEqual(true);
+        });
+
+        it("has certain accessible properties", () => {
+            expect(pi.id).toEqual("platform identifier");
+            expect(pi.name).toEqual("a platform name");
+            expect(pi.parentId).toEqual("the parentId");
+            expect(pi.flaggedForTermination).toEqual(false);
+            expect(pi.global).toEqual(true);
+            expect(
+                forkFake.calledWith(FORK_PATH, [
+                    "the parentId",
+                    "a platform name",
+                    "platform identifier",
+                ]),
+            ).toEqual(true);
+        });
+
+        describe("registerSession", () => {
+            beforeEach(() => {
+                pi.callbackFunction = sandbox.fake();
+            });
+
+            it("adds a close and message handler when a session is registered", () => {
+                pi.registerSession("my session id");
+                expect(pi.callbackFunction.callCount).toEqual(2);
+                sandbox.assert.calledWith(
+                    pi.callbackFunction,
+                    "close",
+                    "my session id",
+                );
+                sandbox.assert.calledWith(
+                    pi.callbackFunction,
+                    "message",
+                    "my session id",
+                );
+                expect(pi.sessions.has("my session id")).toEqual(true);
+            });
+
+            it("is able to generate failure reports", async () => {
+                pi.registerSession("my session id");
+                expect(pi.sessions.has("my session id")).toEqual(true);
+                pi.sendToClient = sandbox.stub();
+                pi.shutdown = sandbox.stub();
+                await pi.reportError("my session id", "an error message");
+                expect(pi.sessions.size).toEqual(0);
+            });
+        });
+
+        it("initializes the job queue", () => {
+            expect(pi.queue).toBeUndefined();
+            pi.initQueue("a secret");
+            expect(pi.queue).toBeDefined();
+        });
+
+        it("cleans up its references when shutdown", async () => {
+            pi.initQueue("a secret");
+            expect(pi.queue).toBeDefined();
+            expect(platformInstances.has("platform identifier")).toBeTrue();
+            await pi.shutdown();
+            expect(pi.queue).toBeUndefined();
+            expect(platformInstances.has("platform identifier")).toBeFalse();
+        });
+
+        it("updates its identifier when changed", () => {
+            pi.updateIdentifier("foo bar");
+            expect(pi.id).toEqual("foo bar");
+            expect(platformInstances.has("platform identifier")).toBeFalse();
+            expect(platformInstances.has("foo bar")).toBeTrue();
+        });
+
+        it("sends messages to client using socket session id", async () => {
+            await pi.sendToClient("my session id", {
+                foo: "this is a message object",
+                sessionSecret: "private data",
+            });
+            expect(getSocketFake.callCount).toEqual(1);
+            sandbox.assert.calledOnce(getSocketFake);
+            sandbox.assert.calledWith(getSocketFake, "my session id");
+            sandbox.assert.calledOnce(socketMock.emit);
+            sandbox.assert.calledWith(socketMock.emit, "message", {
+                foo: "this is a message object",
+                context: "a platform name",
+            });
+        });
+
+        it("broadcasts to peers", async () => {
+            pi.sessions.add("other peer");
+            pi.sessions.add("another peer");
+            await pi.broadcastToSharedPeers("myself", { foo: "bar" });
+            expect(getSocketFake.callCount).toEqual(2);
+            sandbox.assert.calledWith(getSocketFake, "other peer");
+        });
+
+        describe("handleJobResult", () => {
+            beforeEach(() => {
+                pi.sendToClient = sandbox.fake();
+                pi.broadcastToSharedPeers = sandbox.fake();
+                pi.config = { persist: false };
+            });
+
+            it("broadcasts to peers when handling a completed job", async () => {
+                pi.sessions.add("other peer");
+                await pi.handleJobResult(
+                    "completed",
+                    { msg: { foo: "bar" } },
+                    undefined,
+                );
+                expect(pi.sendToClient.callCount).toEqual(1);
+                expect(pi.broadcastToSharedPeers.callCount).toEqual(1);
+            });
+
+            it("appends completed result message when present", async () => {
+                await pi.handleJobResult(
+                    "completed",
+                    { sessionId: "a session id", msg: { foo: "bar" } },
+                    "a good result message",
+                );
+                expect(pi.broadcastToSharedPeers.callCount).toEqual(1);
+                sandbox.assert.calledWith(pi.sendToClient, "a session id", {
+                    foo: "bar",
+                });
+            });
+
+            it("appends failed result message when present", async () => {
+                await pi.handleJobResult(
+                    "failed",
+                    { sessionId: "a session id", msg: { foo: "bar" } },
+                    "a bad result message",
+                );
+                expect(pi.broadcastToSharedPeers.callCount).toEqual(1);
+                sandbox.assert.calledWith(pi.sendToClient, "a session id", {
+                    foo: "bar",
+                    error: "a bad result message",
+                });
+            });
+        });
+
+        describe("callbackFunction", () => {
+            beforeEach(() => {
+                pi.reportError = sandbox.fake();
+                pi.sendToClient = sandbox.fake();
+                pi.updateIdentifier = sandbox.fake();
+            });
+
+            it("close events from platform thread are reported", async () => {
+                // Mock process as connected and not flagged for termination
+                pi.process.connected = true;
+                pi.flaggedForTermination = false;
+
+                const close = pi.callbackFunction("close", "my session id");
+                await close("error msg");
+                sandbox.assert.calledWith(
+                    pi.reportError,
+                    "my session id",
+                    "Error: session thread closed unexpectedly: error msg",
+                );
+            });
+
+            it("close events skip error reporting when process disconnected", async () => {
+                // Mock process as disconnected
+                pi.process.connected = false;
+                pi.flaggedForTermination = false;
+                pi.shutdown = sandbox.stub();
+
+                const close = pi.callbackFunction("close", "my session id");
+                await close("error msg");
+
+                // Should NOT attempt to report error
+                sandbox.assert.notCalled(pi.reportError);
+                // Should call shutdown
+                sandbox.assert.called(pi.shutdown);
+            });
+
+            it("close events skip error reporting when flagged for termination", async () => {
+                // Mock process as flagged for termination
+                pi.process.connected = true;
+                pi.flaggedForTermination = true;
+                pi.shutdown = sandbox.stub();
+
+                const close = pi.callbackFunction("close", "my session id");
+                await close("error msg");
+
+                // Should NOT attempt to report error
+                sandbox.assert.notCalled(pi.reportError);
+                // Should call shutdown
+                sandbox.assert.called(pi.shutdown);
+            });
+
+            it("message events from platform thread are route based on command: error", () => {
+                const message = pi.callbackFunction("message", "my session id");
+                message(["error", "error message"]);
+                sandbox.assert.calledWith(
+                    pi.reportError,
+                    "my session id",
+                    "error message",
+                );
+            });
+
+            it("message events from platform thread are route based on command: updateActor", () => {
+                const message = pi.callbackFunction("message", "my session id");
+                message(["updateActor", undefined, { foo: "bar" }]);
+                sandbox.assert.calledWith(pi.updateIdentifier, { foo: "bar" });
+            });
 
-    describe('handleJobResult', () => {
-      beforeEach(() => {
-        pi.sendToClient = sandbox.fake();
-        pi.broadcastToSharedPeers = sandbox.fake();
-      });
-
-      it('broadcasts to peers when handling a completed job', async () => {
-        pi.sessions.add('other peer');
-        await pi.handleJobResult('completed', {msg: {foo: 'bar'}},
-          undefined);
-        expect(pi.sendToClient.callCount).to.equal(1);
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-      });
-
-      it('appends completed result message when present', async () => {
-        await pi.handleJobResult('completed', {sessionId: 'a session id', msg: {foo: 'bar'}},
-          'a good result message');
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
-          {foo: 'bar'});
-      });
-
-      it('appends failed result message when present', async () => {
-        await pi.handleJobResult('failed', {sessionId: 'a session id', msg: {foo: 'bar'}},
-          'a bad result message');
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
-          {foo: 'bar', error: 'a bad result message'});
-      });
+            it("message events from platform thread are route based on command: else", () => {
+                const message = pi.callbackFunction("message", "my session id");
+                message(["blah", { foo: "bar" }]);
+                sandbox.assert.calledWith(pi.sendToClient, "my session id", {
+                    foo: "bar",
+                });
+            });
+        });
     });
 
-    describe('callbackFunction', () => {
-      beforeEach(() => {
-        pi.reportError = sandbox.fake();
-        pi.sendToClient = sandbox.fake();
-        pi.updateIdentifier = sandbox.fake();
-      });
-
-      it('close events from platform thread are reported', () => {
-        const close = pi.callbackFunction('close', 'my session id');
-        close('error msg');
-        sandbox.assert.calledWith(pi.reportError,
-          'my session id', 'Error: session thread closed unexpectedly: error msg');
-      });
-
-      it('message events from platform thread are route based on command: error', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['error', 'error message']);
-        sandbox.assert.calledWith(pi.reportError, 'my session id', 'error message');
-      });
-
-      it('message events from platform thread are route based on command: updateActor', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['updateActor', undefined, {foo: 'bar'}]);
-        sandbox.assert.calledWith(pi.updateIdentifier, {foo:'bar'});
-      });
-
-      it('message events from platform thread are route based on command: else', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['blah', {foo: 'bar'}]);
-        sandbox.assert.calledWith(pi.sendToClient,
-          'my session id', {foo:'bar'});
-      });
+    describe("credential failure handling", () => {
+        let queueMock: any;
+        let processMock: any;
+
+        beforeEach(() => {
+            queueMock = {
+                pause: sandbox.stub().resolves(),
+                resume: sandbox.stub().resolves(),
+                shutdown: sandbox.stub().resolves(),
+                on: sandbox.stub(),
+                getJob: sandbox.stub(),
+                initResultEvents: sandbox.stub(),
+            };
+
+            processMock = {
+                removeAllListeners: sandbox.stub(),
+                unref: sandbox.stub(),
+                kill: sandbox.stub(),
+            };
+        });
+
+        describe("POSITIVE: Platform initialized - credential failure should NOT terminate", () => {
+            it("should keep platform alive when credential job fails on initialized platform", async () => {
+                const TestPlatformInstance = getTestPlatformInstanceClass();
+                pi = new TestPlatformInstance({
+                    identifier: "test-platform-id",
+                    platform: "xmpp",
+                    parentId: "test-parent",
+                    actor: "testuser@localhost",
+                });
+
+                // Override queue with our mock
+                pi.queue = queueMock;
+                pi.process = processMock;
+
+                // Setup: Platform is already initialized
+                pi.config = {
+                    persist: true,
+                    initialized: true,
+                    requireCredentials: ["connect"],
+                };
+                pi.flaggedForTermination = false;
+
+                const job = {
+                    sessionId: "session123",
+                    msg: {
+                        type: "connect",
+                        context: "xmpp",
+                        actor: { id: "testuser@localhost", type: "person" },
+                    },
+                    title: "xmpp-1",
+                    sessionSecret: "secret",
+                };
+
+                const errorResult = "credentials mismatch for testuser@localhost";
+
+                pi.sendToClient = sandbox.stub();
+
+                // Simulate job failure
+                await pi.handleJobResult("failed", job, errorResult);
+
+                // ASSERTIONS
+                // 1. Platform should NOT be flagged for termination
+                expect(pi.flaggedForTermination).toBe(false);
+
+                // 2. Queue should NOT be paused
+                sinon.assert.notCalled(queueMock.pause);
+
+                // 3. Platform should remain initialized
+                expect(pi.config.initialized).toBe(true);
+
+                // 4. Error should still be sent to client
+                sinon.assert.called(pi.sendToClient);
+            });
+
+            it("should allow subsequent jobs after non-fatal credential error", async () => {
+                const TestPlatformInstance = getTestPlatformInstanceClass();
+                pi = new TestPlatformInstance({
+                    identifier: "test-platform-id",
+                    platform: "xmpp",
+                    parentId: "test-parent",
+                    actor: "testuser@localhost",
+                });
+
+                pi.queue = queueMock;
+                pi.process = processMock;
+
+                pi.config = {
+                    persist: true,
+                    initialized: true,
+                    requireCredentials: ["connect"],
+                };
+                pi.flaggedForTermination = false;
+                pi.sendToClient = sandbox.stub();
+
+                const failedJob = {
+                    sessionId: "session123",
+                    msg: {
+                        type: "connect",
+                        context: "xmpp",
+                        actor: { id: "testuser@localhost", type: "person" },
+                    },
+                    title: "xmpp-1",
+                    sessionSecret: "secret",
+                };
+
+                // First job fails with credential error
+                await pi.handleJobResult("failed", failedJob, "credential error");
+
+                // Platform should still be operational
+                expect(pi.flaggedForTermination).toBe(false);
+                expect(pi.config.initialized).toBe(true);
+
+                // Second job succeeds
+                const successJob = {
+                    sessionId: "session456",
+                    msg: {
+                        type: "send",
+                        context: "xmpp",
+                        actor: { id: "testuser@localhost", type: "person" },
+                    },
+                    title: "xmpp-2",
+                    sessionSecret: "secret",
+                };
+
+                await pi.handleJobResult("completed", successJob, undefined);
+
+                // Platform should still be alive
+                expect(pi.flaggedForTermination).toBe(false);
+                expect(pi.config.initialized).toBe(true);
+            });
+        });
+
+        describe("NEGATIVE: Platform NOT initialized - credential failure SHOULD terminate", () => {
+            it("should terminate platform when credential job fails on uninitialized platform", async () => {
+                const TestPlatformInstance = getTestPlatformInstanceClass();
+                pi = new TestPlatformInstance({
+                    identifier: "test-platform-id",
+                    platform: "xmpp",
+                    parentId: "test-parent",
+                    actor: "testuser@localhost",
+                });
+
+                pi.queue = queueMock;
+                pi.process = processMock;
+
+                // Setup: Platform is NOT initialized
+                pi.config = {
+                    persist: true,
+                    initialized: false,
+                    requireCredentials: ["connect"],
+                };
+                pi.flaggedForTermination = false;
+                pi.sendToClient = sandbox.stub();
+
+                const job = {
+                    sessionId: "session123",
+                    msg: {
+                        type: "connect",
+                        context: "xmpp",
+                        actor: { id: "testuser@localhost", type: "person" },
+                    },
+                    title: "xmpp-1",
+                    sessionSecret: "secret",
+                };
+
+                const errorResult = "invalid credentials for testuser@localhost";
+
+                // Simulate job failure on uninitialized platform
+                await pi.handleJobResult("failed", job, errorResult);
+
+                // ASSERTIONS
+                // 1. Platform SHOULD be flagged for termination
+                expect(pi.flaggedForTermination).toBe(true);
+
+                // 2. Queue SHOULD be paused
+                sinon.assert.calledOnce(queueMock.pause);
+
+                // 3. Platform should remain uninitialized
+                expect(pi.config.initialized).toBe(false);
+
+                // 4. Error should still be sent to client
+                sinon.assert.called(pi.sendToClient);
+            });
+
+            it("should pause queue when credential initialization fails", async () => {
+                const TestPlatformInstance = getTestPlatformInstanceClass();
+                pi = new TestPlatformInstance({
+                    identifier: "test-platform-id",
+                    platform: "xmpp",
+                    parentId: "test-parent",
+                    actor: "testuser@localhost",
+                });
+
+                pi.queue = queueMock;
+                pi.process = processMock;
+
+                pi.config = {
+                    persist: true,
+                    initialized: false,
+                    requireCredentials: ["connect"],
+                };
+                pi.sendToClient = sandbox.stub();
+
+                const job = {
+                    sessionId: "session123",
+                    msg: {
+                        type: "connect",
+                        context: "xmpp",
+                        actor: { id: "testuser@localhost", type: "person" },
+                    },
+                    title: "xmpp-1",
+                    sessionSecret: "secret",
+                };
+
+                await pi.handleJobResult("failed", job, "connection failed");
+
+                // Queue must be paused
+                sinon.assert.calledOnce(queueMock.pause);
+            });
+        });
     });
-  });
 });