From cdce91de6b716e69f4dfec90633615647e24abf4 Mon Sep 17 00:00:00 2001 From: Aaron G Date: Tue, 6 Feb 2024 16:57:45 -0500 Subject: [PATCH] Update depends --- .../{.eslintrc.json => .eslintrc.js} | 0 tests/.eslintrc.js | 5 + tests/.eslintrc.json | 5 - tests/index.action.test.js | 306 ++++---- tests/index.feedclose.test.js | 138 ++-- tests/index.feedopen.test.js | 684 +++++++++--------- tests/index.handshake.test.js | 166 ++--- tests/index.harness.js | 28 +- tests/index.test.js | 530 +++++++------- 9 files changed, 931 insertions(+), 931 deletions(-) rename src/__tests__/{.eslintrc.json => .eslintrc.js} (100%) create mode 100644 tests/.eslintrc.js delete mode 100644 tests/.eslintrc.json diff --git a/src/__tests__/.eslintrc.json b/src/__tests__/.eslintrc.js similarity index 100% rename from src/__tests__/.eslintrc.json rename to src/__tests__/.eslintrc.js diff --git a/tests/.eslintrc.js b/tests/.eslintrc.js new file mode 100644 index 0000000..6052da0 --- /dev/null +++ b/tests/.eslintrc.js @@ -0,0 +1,5 @@ +module.exports = { + env: { + jest: true, + }, +}; diff --git a/tests/.eslintrc.json b/tests/.eslintrc.json deleted file mode 100644 index 55f121d..0000000 --- a/tests/.eslintrc.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "env": { - "jest": true - } -} diff --git a/tests/index.action.test.js b/tests/index.action.test.js index 59cd8ff..ef8de6b 100644 --- a/tests/index.action.test.js +++ b/tests/index.action.test.js @@ -17,8 +17,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -39,8 +39,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -53,7 +53,7 @@ describe("When the transport emits a valid Action message", () => { Success: false, ErrorCode: "INTERNAL_ERROR", ErrorData: {}, - CallbackId: "abc" + CallbackId: "abc", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -83,8 +83,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -98,10 +98,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -164,8 +164,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -185,7 +185,7 @@ describe("When the transport emits a valid Action message", () => { MessageType: "ActionResponse", Success: true, ActionData: { action: "data" }, - CallbackId: "abc" + CallbackId: "abc", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -218,8 +218,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(ares.success({ action: "data" })).toBeUndefined(); @@ -228,8 +228,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -254,8 +254,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -269,10 +269,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -335,8 +335,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -356,7 +356,7 @@ describe("When the transport emits a valid Action message", () => { MessageType: "ActionResponse", Success: true, ActionData: { action: "data" }, - CallbackId: "abc" + CallbackId: "abc", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -389,8 +389,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(ares.success({ action: "data" })).toBeUndefined(); @@ -399,8 +399,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -425,8 +425,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -440,10 +440,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -506,8 +506,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -528,7 +528,7 @@ describe("When the transport emits a valid Action message", () => { Success: false, ErrorCode: "SOME_ERROR", ErrorData: { error: "data" }, - CallbackId: "abc" + CallbackId: "abc", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -561,8 +561,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(ares.failure("SOME_ERROR", { error: "data" })).toBeUndefined(); @@ -571,8 +571,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -597,8 +597,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -612,10 +612,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -678,8 +678,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -700,7 +700,7 @@ describe("When the transport emits a valid Action message", () => { Success: false, ErrorCode: "SOME_ERROR", ErrorData: { error: "data" }, - CallbackId: "abc" + CallbackId: "abc", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -733,8 +733,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(ares.failure("SOME_ERROR", { error: "data" })).toBeUndefined(); @@ -743,8 +743,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -771,8 +771,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -786,10 +786,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -801,7 +801,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -858,8 +858,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -870,7 +870,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -910,14 +910,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(ares.success({ action: "data" })).toBeUndefined(); @@ -926,8 +926,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -952,8 +952,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -967,10 +967,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -982,7 +982,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1039,8 +1039,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1051,7 +1051,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1091,14 +1091,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(ares.success({ action: "data" })).toBeUndefined(); @@ -1107,8 +1107,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -1133,8 +1133,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1148,10 +1148,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -1163,7 +1163,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1220,8 +1220,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1232,7 +1232,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1272,14 +1272,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(ares.failure("SOME_ERROR", { error: "data" })).toBeUndefined(); @@ -1288,8 +1288,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -1314,8 +1314,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1329,10 +1329,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -1344,7 +1344,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1401,8 +1401,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1413,7 +1413,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1453,14 +1453,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(ares.failure("SOME_ERROR", { error: "data" })).toBeUndefined(); @@ -1469,8 +1469,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -1497,8 +1497,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1512,10 +1512,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -1527,7 +1527,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1586,8 +1586,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1598,7 +1598,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1640,14 +1640,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1658,8 +1658,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -1684,8 +1684,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1699,10 +1699,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -1714,7 +1714,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1773,8 +1773,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1785,7 +1785,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1826,14 +1826,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1844,8 +1844,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -1870,8 +1870,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1885,10 +1885,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -1900,7 +1900,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1958,8 +1958,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1970,7 +1970,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2011,14 +2011,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2029,8 +2029,8 @@ describe("When the transport emits a valid Action message", () => { ares.success({ action: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); @@ -2055,8 +2055,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2070,10 +2070,10 @@ describe("When the transport emits a valid Action message", () => { expect(serverListener.action.mock.calls[0][0]).toBeInstanceOf(Object); expect(serverListener.action.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.action.mock.calls[0][0].actionName).toBe( - "some_action" + "some_action", ); expect(serverListener.action.mock.calls[0][0].actionArgs).toEqual({ - action: "args" + action: "args", }); expect(serverListener.action.mock.calls[0][1]).toBeInstanceOf(Object); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -2085,7 +2085,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2143,8 +2143,8 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2155,7 +2155,7 @@ describe("When the transport emits a valid Action message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2196,14 +2196,14 @@ describe("When the transport emits a valid Action message", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "abc" - }) + CallbackId: "abc", + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2214,8 +2214,8 @@ describe("When the transport emits a valid Action message", () => { ares.failure("SOME_ERROR", { error: "data" }); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() or failure() method has already been called." - ) + "ALREADY_RESPONDED: The success() or failure() method has already been called.", + ), ); }); }); diff --git a/tests/index.feedclose.test.js b/tests/index.feedclose.test.js index f1dcc24..88eb5ef 100644 --- a/tests/index.feedclose.test.js +++ b/tests/index.feedclose.test.js @@ -13,7 +13,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); harn.server.emit = jest.fn(); // Can't create a listener @@ -23,8 +23,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -40,7 +40,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); harn.transport.mockClear(); @@ -50,8 +50,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -62,7 +62,7 @@ describe("When the transport emits a valid FeedClose message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -86,8 +86,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -108,8 +108,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -120,7 +120,7 @@ describe("When the transport emits a valid FeedClose message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -142,7 +142,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); const serverListener = harn.createServerListener(); @@ -152,8 +152,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -167,17 +167,17 @@ describe("When the transport emits a valid FeedClose message", () => { expect(serverListener.feedClose.mock.calls.length).toBe(1); expect(serverListener.feedClose.mock.calls[0].length).toBe(2); expect(serverListener.feedClose.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedClose.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedClose.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedClose.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.disconnect.mock.calls.length).toBe(0); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); @@ -229,7 +229,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -243,8 +243,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -263,7 +263,7 @@ describe("When the transport emits a valid FeedClose message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -287,7 +287,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -300,8 +300,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(fcres.success()).toBeUndefined(); @@ -310,8 +310,8 @@ describe("When the transport emits a valid FeedClose message", () => { fcres.success(); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() method has already been called." - ) + "ALREADY_RESPONDED: The success() method has already been called.", + ), ); }); }); @@ -327,7 +327,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); const serverListener = harn.createServerListener(); @@ -337,8 +337,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -352,17 +352,17 @@ describe("When the transport emits a valid FeedClose message", () => { expect(serverListener.feedClose.mock.calls.length).toBe(1); expect(serverListener.feedClose.mock.calls[0].length).toBe(2); expect(serverListener.feedClose.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedClose.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedClose.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedClose.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.disconnect.mock.calls.length).toBe(0); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); @@ -373,7 +373,7 @@ describe("When the transport emits a valid FeedClose message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -420,7 +420,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -434,8 +434,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -446,7 +446,7 @@ describe("When the transport emits a valid FeedClose message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -477,7 +477,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -490,14 +490,14 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(fcres.success()).toBeUndefined(); @@ -506,8 +506,8 @@ describe("When the transport emits a valid FeedClose message", () => { fcres.success(); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() method has already been called." - ) + "ALREADY_RESPONDED: The success() method has already been called.", + ), ); }); }); @@ -523,7 +523,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); const serverListener = harn.createServerListener(); @@ -533,8 +533,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -548,17 +548,17 @@ describe("When the transport emits a valid FeedClose message", () => { expect(serverListener.feedClose.mock.calls.length).toBe(1); expect(serverListener.feedClose.mock.calls[0].length).toBe(2); expect(serverListener.feedClose.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedClose.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedClose.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedClose.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.disconnect.mock.calls.length).toBe(0); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); @@ -569,7 +569,7 @@ describe("When the transport emits a valid FeedClose message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -618,7 +618,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -632,8 +632,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -644,7 +644,7 @@ describe("When the transport emits a valid FeedClose message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -677,7 +677,7 @@ describe("When the transport emits a valid FeedClose message", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); let fcres; harn.server.once("feedClose", (req, res) => { @@ -690,14 +690,14 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -708,8 +708,8 @@ describe("When the transport emits a valid FeedClose message", () => { fcres.success(); }).toThrow( new Error( - "ALREADY_RESPONDED: The success() method has already been called." - ) + "ALREADY_RESPONDED: The success() method has already been called.", + ), ); }); }); @@ -731,8 +731,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -764,8 +764,8 @@ describe("When the transport emits a valid FeedClose message", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -776,7 +776,7 @@ describe("When the transport emits a valid FeedClose message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); diff --git a/tests/index.feedopen.test.js b/tests/index.feedopen.test.js index f4caa21..2e794f1 100644 --- a/tests/index.feedopen.test.js +++ b/tests/index.feedopen.test.js @@ -17,8 +17,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -38,8 +38,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -53,7 +53,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "INTERNAL_ERROR", - ErrorData: {} + ErrorData: {}, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -77,8 +77,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -99,8 +99,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -114,7 +114,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "INTERNAL_ERROR", - ErrorData: {} + ErrorData: {}, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -141,8 +141,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -155,17 +155,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -226,8 +226,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -248,7 +248,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -279,8 +279,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -288,7 +288,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -308,8 +308,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -322,17 +322,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -393,8 +393,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -415,7 +415,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -446,8 +446,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -455,7 +455,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -475,8 +475,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -489,17 +489,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -560,8 +560,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -583,7 +583,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -614,18 +614,18 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -645,8 +645,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -659,17 +659,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -730,8 +730,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -753,7 +753,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -784,18 +784,18 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -817,8 +817,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -831,17 +831,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -853,7 +853,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -908,8 +908,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -920,7 +920,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -958,14 +958,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -973,7 +973,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -993,8 +993,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1007,17 +1007,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1029,7 +1029,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1084,8 +1084,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1096,7 +1096,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1134,14 +1134,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -1149,7 +1149,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -1169,8 +1169,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1183,17 +1183,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1205,7 +1205,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1260,8 +1260,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1272,7 +1272,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1310,24 +1310,24 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -1347,8 +1347,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1361,17 +1361,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1383,7 +1383,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -1438,8 +1438,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1450,7 +1450,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -1488,24 +1488,24 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -1527,8 +1527,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1541,17 +1541,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1563,7 +1563,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1620,8 +1620,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1632,7 +1632,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1672,14 +1672,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1689,7 +1689,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -1709,8 +1709,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1723,17 +1723,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1745,7 +1745,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1802,8 +1802,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1814,7 +1814,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1854,14 +1854,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1871,7 +1871,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -1891,8 +1891,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -1905,17 +1905,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -1927,7 +1927,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -1984,8 +1984,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -1996,7 +1996,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2036,26 +2036,26 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2075,8 +2075,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2089,17 +2089,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2111,7 +2111,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2168,8 +2168,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2180,7 +2180,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -2220,26 +2220,26 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2264,8 +2264,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2278,17 +2278,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2350,8 +2350,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2372,7 +2372,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -2404,8 +2404,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -2413,7 +2413,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2434,8 +2434,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2448,17 +2448,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2520,8 +2520,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2542,7 +2542,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -2574,8 +2574,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -2583,7 +2583,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2604,8 +2604,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2618,17 +2618,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2690,8 +2690,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2713,7 +2713,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -2745,18 +2745,18 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2777,8 +2777,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2791,17 +2791,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2863,8 +2863,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2886,7 +2886,7 @@ describe("When the transport emits a valid FeedOpen message", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -2918,18 +2918,18 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -2952,8 +2952,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -2966,17 +2966,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -2988,7 +2988,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -3044,8 +3044,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3056,7 +3056,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -3095,14 +3095,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -3110,7 +3110,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -3131,8 +3131,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -3145,17 +3145,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -3167,7 +3167,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -3223,8 +3223,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3235,7 +3235,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -3274,14 +3274,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(fores.success({ feed: "data" })).toBeUndefined(); @@ -3289,7 +3289,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -3310,8 +3310,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -3324,17 +3324,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -3346,7 +3346,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -3402,8 +3402,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3414,7 +3414,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -3453,24 +3453,24 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -3491,8 +3491,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -3505,17 +3505,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -3527,7 +3527,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -3583,8 +3583,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3595,7 +3595,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -3634,24 +3634,24 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -3674,8 +3674,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -3688,17 +3688,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -3710,7 +3710,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -3768,8 +3768,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3780,7 +3780,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -3821,14 +3821,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -3838,7 +3838,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -3859,8 +3859,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -3873,17 +3873,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -3895,7 +3895,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -3953,8 +3953,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -3965,7 +3965,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4006,14 +4006,14 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4023,7 +4023,7 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -4044,8 +4044,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -4058,17 +4058,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -4080,7 +4080,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4138,8 +4138,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -4150,7 +4150,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4191,26 +4191,26 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.success({ feed: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); @@ -4231,8 +4231,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -4245,17 +4245,17 @@ describe("When the transport emits a valid FeedOpen message", () => { expect(serverListener.feedOpen.mock.calls.length).toBe(1); expect(serverListener.feedOpen.mock.calls[0].length).toBe(2); expect(serverListener.feedOpen.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedOpen.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.feedOpen.mock.calls[0][0].feedName).toBe( - "some_feed" + "some_feed", ); expect(serverListener.feedOpen.mock.calls[0][0].feedArgs).toEqual({ - feed: "args" + feed: "args", }); expect(serverListener.feedOpen.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.feedClose.mock.calls.length).toBe(0); expect(serverListener.disconnect.mock.calls.length).toBe(0); @@ -4267,7 +4267,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4325,8 +4325,8 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -4337,7 +4337,7 @@ describe("When the transport emits a valid FeedOpen message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -4378,26 +4378,26 @@ describe("When the transport emits a valid FeedOpen message", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); expect( - fores.failure("SOME_ERROR", { error: "data" }) + fores.failure("SOME_ERROR", { error: "data" }), ).toBeUndefined(); expect(() => { fores.failure("SOME_ERROR", { error: "data" }); }).toThrow( - "ALREADY_RESPONDED: The success() or failure() method has already been called." + "ALREADY_RESPONDED: The success() or failure() method has already been called.", ); }); }); diff --git a/tests/index.handshake.test.js b/tests/index.handshake.test.js index d6c2b16..ab76ef9 100644 --- a/tests/index.handshake.test.js +++ b/tests/index.handshake.test.js @@ -7,7 +7,7 @@ describe("When the transport emits a valid Handshake message", () => { it("should emit no events", () => { const harn = harness({ - handshakeMs: 0 // Don't leave a pending timer (Jest warns) + handshakeMs: 0, // Don't leave a pending timer (Jest warns) }); harn.makeServerStarted(); harn.transport.emit("connect", "some_tcid"); @@ -18,8 +18,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -29,7 +29,7 @@ describe("When the transport emits a valid Handshake message", () => { it("should return HandshakeResponse indicating failure", () => { const harn = harness({ - handshakeMs: 0 // Don't leave a pending timer (Jest warns) + handshakeMs: 0, // Don't leave a pending timer (Jest warns) }); harn.makeServerStarted(); harn.transport.emit("connect", "some_tcid"); @@ -40,8 +40,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -51,7 +51,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(harn.transport.send.mock.calls[0][0]).toBe("some_tcid"); expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", - Success: false + Success: false, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -71,8 +71,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -91,8 +91,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -103,7 +103,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", Success: true, - Version: "0.1" + Version: "0.1", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -122,8 +122,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); harn.server.emit = jest.fn(); // Can't listen @@ -132,8 +132,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.server.emit.mock.calls.length).toBe(0); @@ -151,8 +151,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); harn.transport.mockClear(); @@ -161,8 +161,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -173,7 +173,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", Success: true, - Version: "0.1" + Version: "0.1", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -186,7 +186,7 @@ describe("When the transport emits a valid Handshake message", () => { it("should emit no events", () => { const harn = harness({ - handshakeMs: 0 // Don't leave a pending timer (Jest warns) + handshakeMs: 0, // Don't leave a pending timer (Jest warns) }); harn.makeServerStarted(); harn.transport.emit("connect", "some_tcid"); @@ -197,8 +197,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -219,7 +219,7 @@ describe("When the transport emits a valid Handshake message", () => { it("should return HandshakeResponse indicating failure", () => { const harn = harness({ - handshakeMs: 0 // Don't leave a pending timer (Jest warns) + handshakeMs: 0, // Don't leave a pending timer (Jest warns) }); harn.makeServerStarted(); harn.transport.emit("connect", "some_tcid"); @@ -230,8 +230,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -241,7 +241,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(harn.transport.send.mock.calls[0][0]).toBe("some_tcid"); expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", - Success: false + Success: false, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -255,7 +255,7 @@ describe("When the transport emits a valid Handshake message", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -266,8 +266,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -278,11 +278,11 @@ describe("When the transport emits a valid Handshake message", () => { expect(serverListener.handshake.mock.calls.length).toBe(1); expect(serverListener.handshake.mock.calls[0].length).toBe(2); expect(serverListener.handshake.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.handshake.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.handshake.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.action.mock.calls.length).toBe(0); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -345,8 +345,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -365,7 +365,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", Success: true, - Version: "0.1" + Version: "0.1", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -396,8 +396,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(hres.success()).toBeUndefined(); @@ -405,7 +405,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(() => { hres.success(); }).toThrow( - "ALREADY_RESPONDED: The success() method has already been called." + "ALREADY_RESPONDED: The success() method has already been called.", ); }); }); @@ -417,7 +417,7 @@ describe("When the transport emits a valid Handshake message", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -428,8 +428,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -440,11 +440,11 @@ describe("When the transport emits a valid Handshake message", () => { expect(serverListener.handshake.mock.calls.length).toBe(1); expect(serverListener.handshake.mock.calls[0].length).toBe(2); expect(serverListener.handshake.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.handshake.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.handshake.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.action.mock.calls.length).toBe(0); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -458,7 +458,7 @@ describe("When the transport emits a valid Handshake message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); serverListener.mockClear(); @@ -513,8 +513,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -525,7 +525,7 @@ describe("When the transport emits a valid Handshake message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); harn.transport.mockClear(); @@ -563,14 +563,14 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("FAILURE: ...") + new Error("FAILURE: ..."), ); expect(hres.success()).toBeUndefined(); @@ -578,7 +578,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(() => { hres.success(); }).toThrow( - "ALREADY_RESPONDED: The success() method has already been called." + "ALREADY_RESPONDED: The success() method has already been called.", ); }); }); @@ -590,7 +590,7 @@ describe("When the transport emits a valid Handshake message", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -601,8 +601,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -613,11 +613,11 @@ describe("When the transport emits a valid Handshake message", () => { expect(serverListener.handshake.mock.calls.length).toBe(1); expect(serverListener.handshake.mock.calls[0].length).toBe(2); expect(serverListener.handshake.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.handshake.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.handshake.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.action.mock.calls.length).toBe(0); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -631,7 +631,7 @@ describe("When the transport emits a valid Handshake message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -688,8 +688,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -700,7 +700,7 @@ describe("When the transport emits a valid Handshake message", () => { harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -740,14 +740,14 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); harn.transport.emit( "disconnect", "some_tcid", - new Error("STOPPING: ...") + new Error("STOPPING: ..."), ); harn.transport.state.mockReturnValue("stopping"); harn.transport.emit("stopping", new Error("FAILURE: ...")); @@ -757,7 +757,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(() => { hres.success(); }).toThrow( - "ALREADY_RESPONDED: The success() method has already been called." + "ALREADY_RESPONDED: The success() method has already been called.", ); }); }); @@ -771,7 +771,7 @@ describe("When the transport emits a valid Handshake message", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -782,8 +782,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -805,8 +805,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(serverListener.starting.mock.calls.length).toBe(0); @@ -817,11 +817,11 @@ describe("When the transport emits a valid Handshake message", () => { expect(serverListener.handshake.mock.calls.length).toBe(1); expect(serverListener.handshake.mock.calls[0].length).toBe(2); expect(serverListener.handshake.mock.calls[0][0]).toBeInstanceOf( - Object + Object, ); expect(serverListener.handshake.mock.calls[0][0].clientId).toBe(cid); expect(serverListener.handshake.mock.calls[0][1]).toBeInstanceOf( - Object + Object, ); expect(serverListener.action.mock.calls.length).toBe(0); expect(serverListener.feedOpen.mock.calls.length).toBe(0); @@ -884,8 +884,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -895,7 +895,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(harn.transport.send.mock.calls[0][0]).toBe("some_tcid"); expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", - Success: false + Success: false, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -905,8 +905,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -925,7 +925,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "HandshakeResponse", Success: true, - Version: "0.1" + Version: "0.1", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -956,8 +956,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["X.X"] - }) + Versions: ["X.X"], + }), ); harn.transport.emit( @@ -965,8 +965,8 @@ describe("When the transport emits a valid Handshake message", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); expect(hres.success()).toBeUndefined(); @@ -974,7 +974,7 @@ describe("When the transport emits a valid Handshake message", () => { expect(() => { hres.success(); }).toThrow( - "ALREADY_RESPONDED: The success() method has already been called." + "ALREADY_RESPONDED: The success() method has already been called.", ); }); }); diff --git a/tests/index.harness.js b/tests/index.harness.js index 874f995..b6ecfd5 100644 --- a/tests/index.harness.js +++ b/tests/index.harness.js @@ -46,7 +46,7 @@ harnessProto.createServerListener = function createServerListener() { feedClose: jest.fn(), disconnect: jest.fn(), badClientMessage: jest.fn(), - transportError: jest.fn() + transportError: jest.fn(), }; l.mockClear = function mockClear() { l.starting.mockClear(); @@ -101,8 +101,8 @@ harnessProto.makeClient = function connectClient(tcid) { tcid, JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); this.transport.mockClear(); return cid; @@ -122,8 +122,8 @@ harnessProto.makeFeedOpening = function makeFeedOpening(tcid, fn, fa) { JSON.stringify({ MessageType: "FeedOpen", FeedName: fn, - FeedArgs: fa - }) + FeedArgs: fa, + }), ); this.transport.mockClear(); return res; @@ -141,8 +141,8 @@ harnessProto.makeFeedOpen = function makeFeedOpening(tcid, fn, fa, fd) { JSON.stringify({ MessageType: "FeedOpen", FeedName: fn, - FeedArgs: fa - }) + FeedArgs: fa, + }), ); this.transport.mockClear(); }; @@ -160,8 +160,8 @@ harnessProto.makeFeedClosing = function makeFeedOpening(tcid, fn, fa) { JSON.stringify({ MessageType: "FeedOpen", FeedName: fn, - FeedArgs: fa - }) + FeedArgs: fa, + }), ); let res; @@ -174,8 +174,8 @@ harnessProto.makeFeedClosing = function makeFeedOpening(tcid, fn, fa) { JSON.stringify({ MessageType: "FeedClose", FeedName: fn, - FeedArgs: fa - }) + FeedArgs: fa, + }), ); this.transport.mockClear(); return res; @@ -193,8 +193,8 @@ harnessProto.makeFeedTerminated = function makeFeedOpening(tcid, fn, fa) { JSON.stringify({ MessageType: "FeedOpen", FeedName: fn, - FeedArgs: fa - }) + FeedArgs: fa, + }), ); this.server.feedTermination({ @@ -202,7 +202,7 @@ harnessProto.makeFeedTerminated = function makeFeedOpening(tcid, fn, fa) { feedName: fn, feedArgs: fa, errorCode: "DISCARDED_CODE", - errorData: { discarded: "data" } + errorData: { discarded: "data" }, }); this.transport.mockClear(); diff --git a/tests/index.test.js b/tests/index.test.js index ce6f4f4..9276332 100644 --- a/tests/index.test.js +++ b/tests/index.test.js @@ -145,8 +145,8 @@ describe("The handshakeMs option", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); // Check transport calls @@ -218,8 +218,8 @@ describe("The handshakeMs option", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); // Check transport calls @@ -402,7 +402,7 @@ describe("The handshakeMs option", () => { const serverListener = harn.createServerListener(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -450,7 +450,7 @@ describe("The handshakeMs option", () => { expect(harn.transport.disconnect.mock.calls[0][0]).toBe("some_tcid"); expect(harn.transport.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(harn.transport.disconnect.mock.calls[0][1].message).toBe( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", ); // Transport required to emit a disconnect event @@ -458,8 +458,8 @@ describe("The handshakeMs option", () => { "disconnect", "some_tcid", new Error( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." - ) + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", + ), ); // Check server events @@ -477,7 +477,7 @@ describe("The handshakeMs option", () => { expect(serverListener.disconnect.mock.calls[0][0]).toBe(cid); expect(serverListener.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(serverListener.disconnect.mock.calls[0][1].message).toBe( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", ); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); expect(serverListener.transportError.mock.calls.length).toBe(0); @@ -516,7 +516,7 @@ describe("The handshakeMs option", () => { const serverListener = harn.createServerListener(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -591,7 +591,7 @@ describe("The handshakeMs option", () => { expect(harn.transport.disconnect.mock.calls[0][0]).toBe("some_tcid"); expect(harn.transport.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(harn.transport.disconnect.mock.calls[0][1].message).toBe( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", ); // Transport required to emit a disconnect event @@ -599,8 +599,8 @@ describe("The handshakeMs option", () => { "disconnect", "some_tcid", new Error( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." - ) + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", + ), ); // Check server events @@ -618,7 +618,7 @@ describe("The handshakeMs option", () => { expect(serverListener.disconnect.mock.calls[0][0]).toBe(cid); expect(serverListener.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(serverListener.disconnect.mock.calls[0][1].message).toBe( - "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time." + "HANDSHAKE_TIMEOUT: The client did not complete a handshake within the configured amount of time.", ); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); expect(serverListener.transportError.mock.calls.length).toBe(0); @@ -669,8 +669,8 @@ describe("The handshakeMs option", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); // Check transport calls @@ -742,8 +742,8 @@ describe("The handshakeMs option", () => { "some_tcid", JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] - }) + Versions: ["0.1"], + }), ); // Check transport calls @@ -967,8 +967,8 @@ describe("The terminationMs option", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); // Check transport calls @@ -980,7 +980,7 @@ describe("The terminationMs option", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1046,8 +1046,8 @@ describe("The terminationMs option", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); // Check transport calls @@ -1089,7 +1089,7 @@ describe("The terminationMs option", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1155,8 +1155,8 @@ describe("The terminationMs option", () => { JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); // Check transport calls @@ -1168,7 +1168,7 @@ describe("The terminationMs option", () => { expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual({ MessageType: "FeedCloseResponse", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1230,7 +1230,7 @@ describe("The terminationMs option", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -1244,8 +1244,8 @@ describe("The terminationMs option", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedClose message." - } + Problem: "Unexpected FeedClose message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1264,10 +1264,10 @@ describe("The terminationMs option", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated." + "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated.", ); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -1320,8 +1320,8 @@ describe("The terminationMs option", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); // Check transport calls @@ -1363,7 +1363,7 @@ describe("The terminationMs option", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1430,8 +1430,8 @@ describe("The terminationMs option", () => { JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } - }) + FeedArgs: { feed: "args" }, + }), ); // Check transport calls @@ -1473,7 +1473,7 @@ describe("The terminationMs option", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, Success: true, - FeedData: { feed: "data" } + FeedData: { feed: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); @@ -1541,7 +1541,7 @@ describe("The factory function", () => { expect(() => { feedmeServerCore({ transport: {} }); }).toThrow( - "INVALID_ARGUMENT: The supplied transport does not implement the required API." + "INVALID_ARGUMENT: The supplied transport does not implement the required API.", ); }); @@ -1555,9 +1555,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - handshakeMs: {} + handshakeMs: {}, }); }).toThrow("INVALID_ARGUMENT: The supplied transport is not stopped."); }); @@ -1572,9 +1572,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - handshakeMs: {} + handshakeMs: {}, }); }).toThrow("INVALID_ARGUMENT: Invalid options.handshakeMs."); }); @@ -1589,9 +1589,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - handshakeMs: 1.5 + handshakeMs: 1.5, }); }).toThrow("INVALID_ARGUMENT: Invalid options.handshakeMs."); }); @@ -1606,9 +1606,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - handshakeMs: -1 + handshakeMs: -1, }); }).toThrow("INVALID_ARGUMENT: Invalid options.handshakeMs."); }); @@ -1623,9 +1623,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - terminationMs: {} + terminationMs: {}, }); }).toThrow("INVALID_ARGUMENT: Invalid options.terminationMs."); }); @@ -1640,9 +1640,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - terminationMs: 1.5 + terminationMs: 1.5, }); }).toThrow("INVALID_ARGUMENT: Invalid options.terminationMs."); }); @@ -1657,9 +1657,9 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} + disconnect: () => {}, }, - terminationMs: -1 + terminationMs: -1, }); }).toThrow("INVALID_ARGUMENT: Invalid options.terminationMs."); }); @@ -1675,10 +1675,10 @@ describe("The factory function", () => { start: () => {}, stop: () => {}, send: () => {}, - disconnect: () => {} - } - }) - ) + disconnect: () => {}, + }, + }), + ), ).toBe(true); }); @@ -1694,10 +1694,10 @@ describe("The factory function", () => { start: jest.fn(), stop: jest.fn(), send: jest.fn(), - disconnect: jest.fn() + disconnect: jest.fn(), }; feedmeServerCore({ - transport: t + transport: t, }); expect(t.start.mock.calls.length).toBe(0); expect(t.stop.mock.calls.length).toBe(0); @@ -1820,7 +1820,7 @@ describe("The server.start() function", () => { expect(serverListener.stopping.mock.calls[0].length).toBe(1); expect(serverListener.stopping.mock.calls[0][0]).toBeInstanceOf(Error); expect(serverListener.stopping.mock.calls[0][0].message).toBe( - "FAILURE: ..." + "FAILURE: ...", ); expect(serverListener.stop.mock.calls.length).toBe(0); expect(serverListener.connect.mock.calls.length).toBe(0); @@ -1966,7 +1966,7 @@ describe("The server.actionRevelation() function", () => { actionData: { action: "data" }, feedName: "some_feed", feedArgs: { feed: "args" }, - feedDeltas: [] + feedDeltas: [], }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -1982,7 +1982,7 @@ describe("The server.actionRevelation() function", () => { actionData: { action: "data" }, feedName: "some_feed", feedArgs: { feed: "args" }, - feedDeltas: [] + feedDeltas: [], }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -2002,7 +2002,7 @@ describe("The server.actionRevelation() function", () => { actionData: { action: "data" }, feedName: "some_feed", feedArgs: { feed: "args" }, - feedDeltas: [] + feedDeltas: [], }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -2020,8 +2020,8 @@ describe("The server.actionRevelation() function", () => { actionData: { action: "data" }, feedName: "some_feed", feedArgs: { feed: "args" }, - feedDeltas: [] - }) + feedDeltas: [], + }), ).toBeUndefined(); }); @@ -2039,7 +2039,7 @@ describe("The server.actionRevelation() function", () => { "closed_name", "other_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed closed - different feed arg open @@ -2048,7 +2048,7 @@ describe("The server.actionRevelation() function", () => { "closed_args", "some_feed", { other: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed opening @@ -2078,10 +2078,10 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } - ] + new: "data", + }, + }, + ], }); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2100,10 +2100,10 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } - ] + new: "data", + }, + }, + ], }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2118,7 +2118,7 @@ describe("The server.actionRevelation() function", () => { "closed_name", "other_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed closed - different feed arg open @@ -2127,7 +2127,7 @@ describe("The server.actionRevelation() function", () => { "closed_args", "some_feed", { other: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed opening @@ -2157,11 +2157,11 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } + new: "data", + }, + }, ], - feedData: { new: "data" } + feedData: { new: "data" }, }); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2180,11 +2180,11 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } + new: "data", + }, + }, ], - FeedMd5: "pBTE+QEe33IXncYf8DOPgA==" // Hashing checked in unit tests + FeedMd5: "pBTE+QEe33IXncYf8DOPgA==", // Hashing checked in unit tests }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2199,7 +2199,7 @@ describe("The server.actionRevelation() function", () => { "closed_name", "other_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed closed - different feed arg open @@ -2208,7 +2208,7 @@ describe("The server.actionRevelation() function", () => { "closed_args", "some_feed", { other: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed opening @@ -2238,11 +2238,11 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } + new: "data", + }, + }, ], - feedMd5: "pBTE+QEe33IXncYf8DOPgA==" + feedMd5: "pBTE+QEe33IXncYf8DOPgA==", }); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2261,11 +2261,11 @@ describe("The server.actionRevelation() function", () => { Operation: "Set", Path: [], Value: { - new: "data" - } - } + new: "data", + }, + }, ], - FeedMd5: "pBTE+QEe33IXncYf8DOPgA==" + FeedMd5: "pBTE+QEe33IXncYf8DOPgA==", }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2282,7 +2282,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -2298,7 +2298,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -2318,7 +2318,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); }).toThrow(new Error("INVALID_STATE: The server is not started.")); }); @@ -2336,8 +2336,8 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } - }) + errorData: { error: "data" }, + }), ).toBeUndefined(); }); @@ -2379,7 +2379,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2393,7 +2393,7 @@ describe("The server.feedTermination() function", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2408,7 +2408,7 @@ describe("The server.feedTermination() function", () => { "target", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); // Other feeds on target client @@ -2416,13 +2416,13 @@ describe("The server.feedTermination() function", () => { "target", "other_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); harn.makeFeedOpen( "target", "some_feed", { other: "args" }, - { feed: "data" } + { feed: "data" }, ); // Other client on target feed: feed opening @@ -2447,7 +2447,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2460,7 +2460,7 @@ describe("The server.feedTermination() function", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2476,7 +2476,7 @@ describe("The server.feedTermination() function", () => { "target", "open_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); harn.makeFeedClosing("target", "closing_feed", { feed: "args" }); harn.makeFeedTerminated("target", "terminated_feed", { feed: "args" }); @@ -2492,7 +2492,7 @@ describe("The server.feedTermination() function", () => { harn.server.feedTermination({ clientId: cidTarget, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); const feedTerminationExpected = { @@ -2500,7 +2500,7 @@ describe("The server.feedTermination() function", () => { FeedName: "open_feed", FeedArgs: { feed: "args" }, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }; const feedOpenResponseExpected = { MessageType: "FeedOpenResponse", @@ -2508,7 +2508,7 @@ describe("The server.feedTermination() function", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }; expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2524,7 +2524,7 @@ describe("The server.feedTermination() function", () => { (_.isEqual(received1, feedTerminationExpected) && _.isEqual(received2, feedOpenResponseExpected)) || (_.isEqual(received2, feedTerminationExpected) && - _.isEqual(received1, feedOpenResponseExpected)) + _.isEqual(received1, feedOpenResponseExpected)), ).toBe(true); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -2539,7 +2539,7 @@ describe("The server.feedTermination() function", () => { "closed_name", "other_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed closed - different feed arg open @@ -2548,7 +2548,7 @@ describe("The server.feedTermination() function", () => { "closed_args", "some_feed", { other: "args" }, - { feed: "data" } + { feed: "data" }, ); // Feed opening @@ -2572,7 +2572,7 @@ describe("The server.feedTermination() function", () => { feedName: "some_feed", feedArgs: { feed: "args" }, errorCode: "SOME_ERROR", - errorData: { error: "data" } + errorData: { error: "data" }, }); const feedTerminationExpected = { @@ -2580,7 +2580,7 @@ describe("The server.feedTermination() function", () => { FeedName: "some_feed", FeedArgs: { feed: "args" }, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }; const feedOpenResponseExpected = { MessageType: "FeedOpenResponse", @@ -2588,7 +2588,7 @@ describe("The server.feedTermination() function", () => { FeedArgs: { feed: "args" }, Success: false, ErrorCode: "SOME_ERROR", - ErrorData: { error: "data" } + ErrorData: { error: "data" }, }; expect(harn.transport.start.mock.calls.length).toBe(0); @@ -2599,20 +2599,20 @@ describe("The server.feedTermination() function", () => { if (harn.transport.send.mock.calls[0][0] === "opening") { expect(harn.transport.send.mock.calls[0][0]).toBe("opening"); expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual( - feedOpenResponseExpected + feedOpenResponseExpected, ); expect(harn.transport.send.mock.calls[1][0]).toBe("open"); expect(JSON.parse(harn.transport.send.mock.calls[1][1])).toEqual( - feedTerminationExpected + feedTerminationExpected, ); } else { expect(harn.transport.send.mock.calls[0][0]).toBe("open"); expect(JSON.parse(harn.transport.send.mock.calls[0][1])).toEqual( - feedTerminationExpected + feedTerminationExpected, ); expect(harn.transport.send.mock.calls[1][0]).toBe("opening"); expect(JSON.parse(harn.transport.send.mock.calls[1][1])).toEqual( - feedOpenResponseExpected + feedOpenResponseExpected, ); } }); @@ -2791,7 +2791,7 @@ describe("When the transport violates a library requirement", () => { expect(serverListener.transportError.mock.calls.length).toBe(1); expect(serverListener.transportError.mock.calls[0].length).toBe(1); expect(serverListener.transportError.mock.calls[0][0]).toBeInstanceOf( - Error + Error, ); }); @@ -2832,7 +2832,7 @@ describe("When the transport emits stopping/stop events (failure)", () => { expect(serverListener.disconnect.mock.calls[0][0]).toBe(cid); expect(serverListener.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(serverListener.disconnect.mock.calls[0][1].message).toBe( - "STOPPING: ..." + "STOPPING: ...", ); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); expect(serverListener.transportError.mock.calls.length).toBe(0); @@ -2846,7 +2846,7 @@ describe("When the transport emits stopping/stop events (failure)", () => { expect(serverListener.stopping.mock.calls[0].length).toBe(1); expect(serverListener.stopping.mock.calls[0][0]).toBeInstanceOf(Error); expect(serverListener.stopping.mock.calls[0][0].message).toBe( - "FAILURE: ..." + "FAILURE: ...", ); expect(serverListener.stop.mock.calls.length).toBe(0); expect(serverListener.connect.mock.calls.length).toBe(0); @@ -2973,7 +2973,7 @@ describe("When the transport emits a disconnect event (failure)", () => { expect(serverListener.disconnect.mock.calls[0][0]).toBe(cid); expect(serverListener.disconnect.mock.calls[0][1]).toBeInstanceOf(Error); expect(serverListener.disconnect.mock.calls[0][1].message).toBe( - "FAILURE: ..." + "FAILURE: ...", ); expect(serverListener.badClientMessage.mock.calls.length).toBe(0); expect(serverListener.transportError.mock.calls.length).toBe(0); @@ -3023,16 +3023,16 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Invalid JSON." + "INVALID_MESSAGE: Invalid JSON.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].parseError + serverListener.badClientMessage.mock.calls[0][1].parseError, ).toBeInstanceOf(Error); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3056,8 +3056,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Invalid JSON." - } + Problem: "Invalid JSON.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3089,18 +3089,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(JSON.parse(msg)); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3124,8 +3124,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3141,7 +3141,7 @@ describe("When the transport emits an invalid message event", () => { const serverListener = harn.createServerListener(); const msgObject = { - MessageType: "junk" + MessageType: "junk", }; const msg = JSON.stringify(msgObject); harn.transport.emit("message", "some_tcid", msg); @@ -3160,18 +3160,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toEqual(msgObject); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3184,7 +3184,7 @@ describe("When the transport emits an invalid message event", () => { harn.makeClient("some_tcid"); const msg = JSON.stringify({ - MessageType: "junk" + MessageType: "junk", }); harn.transport.emit("message", "some_tcid", msg); @@ -3197,8 +3197,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3214,7 +3214,7 @@ describe("When the transport emits an invalid message event", () => { const serverListener = harn.createServerListener(); const msgObject = { - MessageType: "Handshake" + MessageType: "Handshake", }; const msg = JSON.stringify(msgObject); harn.transport.emit("message", "some_tcid", msg); @@ -3233,18 +3233,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toEqual(msgObject); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3257,7 +3257,7 @@ describe("When the transport emits an invalid message event", () => { harn.makeClient("some_tcid"); const msg = JSON.stringify({ - MessageType: "Handshake" + MessageType: "Handshake", }); harn.transport.emit("message", "some_tcid", msg); @@ -3270,8 +3270,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3287,7 +3287,7 @@ describe("When the transport emits an invalid message event", () => { const serverListener = harn.createServerListener(); const msgObject = { - MessageType: "Action" + MessageType: "Action", }; const msg = JSON.stringify(msgObject); harn.transport.emit("message", "some_tcid", msg); @@ -3306,18 +3306,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toEqual(msgObject); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3330,7 +3330,7 @@ describe("When the transport emits an invalid message event", () => { harn.makeClient("some_tcid"); const msg = JSON.stringify({ - MessageType: "Action" + MessageType: "Action", }); harn.transport.emit("message", "some_tcid", msg); @@ -3343,8 +3343,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3360,7 +3360,7 @@ describe("When the transport emits an invalid message event", () => { const serverListener = harn.createServerListener(); const msgObject = { - MessageType: "FeedOpen" + MessageType: "FeedOpen", }; const msg = JSON.stringify(msgObject); harn.transport.emit("message", "some_tcid", msg); @@ -3379,18 +3379,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toEqual(msgObject); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3403,7 +3403,7 @@ describe("When the transport emits an invalid message event", () => { harn.makeClient("some_tcid"); const msg = JSON.stringify({ - MessageType: "FeedOpen" + MessageType: "FeedOpen", }); harn.transport.emit("message", "some_tcid", msg); @@ -3416,8 +3416,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3433,7 +3433,7 @@ describe("When the transport emits an invalid message event", () => { const serverListener = harn.createServerListener(); const msgObject = { - MessageType: "FeedClose" + MessageType: "FeedClose", }; const msg = JSON.stringify(msgObject); harn.transport.emit("message", "some_tcid", msg); @@ -3452,18 +3452,18 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "INVALID_MESSAGE: Schema violation." + "INVALID_MESSAGE: Schema violation.", ); expect( check.string( - serverListener.badClientMessage.mock.calls[0][1].schemaViolation - ) + serverListener.badClientMessage.mock.calls[0][1].schemaViolation, + ), ).toBe(true); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toEqual(msgObject); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3476,7 +3476,7 @@ describe("When the transport emits an invalid message event", () => { harn.makeClient("some_tcid"); const msg = JSON.stringify({ - MessageType: "FeedClose" + MessageType: "FeedClose", }); harn.transport.emit("message", "some_tcid", msg); @@ -3489,8 +3489,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Schema violation." - } + Problem: "Schema violation.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3508,7 +3508,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] + Versions: ["0.1"], }); harn.transport.emit("message", "some_tcid", msg); @@ -3529,13 +3529,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: Unexpected Handshake message." + "UNEXPECTED_MESSAGE: Unexpected Handshake message.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3549,7 +3549,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "Handshake", - Versions: ["0.1"] + Versions: ["0.1"], }); harn.transport.emit("message", "some_tcid", msg); @@ -3565,8 +3565,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected Handshake message." - } + Problem: "Unexpected Handshake message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3579,7 +3579,7 @@ describe("When the transport emits an invalid message event", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -3589,7 +3589,7 @@ describe("When the transport emits an invalid message event", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "123" + CallbackId: "123", }); harn.transport.emit("message", "some_tcid", msg); @@ -3607,13 +3607,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: Action message received before successful Handshake." + "UNEXPECTED_MESSAGE: Action message received before successful Handshake.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3629,7 +3629,7 @@ describe("When the transport emits an invalid message event", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "123" + CallbackId: "123", }); harn.transport.emit("message", "some_tcid", msg); @@ -3642,8 +3642,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Handshake required." - } + Problem: "Handshake required.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3662,7 +3662,7 @@ describe("When the transport emits an invalid message event", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "123" + CallbackId: "123", }); harn.transport.emit("message", "some_tcid", msg); @@ -3683,13 +3683,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: Action message reused an outstanding CallbackId." + "UNEXPECTED_MESSAGE: Action message reused an outstanding CallbackId.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3706,7 +3706,7 @@ describe("When the transport emits an invalid message event", () => { MessageType: "Action", ActionName: "some_action", ActionArgs: { action: "args" }, - CallbackId: "123" + CallbackId: "123", }); harn.transport.emit("message", "some_tcid", msg); @@ -3722,8 +3722,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Action message reused an outstanding CallbackId." - } + Problem: "Action message reused an outstanding CallbackId.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3736,7 +3736,7 @@ describe("When the transport emits an invalid message event", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -3745,7 +3745,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3763,13 +3763,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedOpen message received before successful Handshake." + "UNEXPECTED_MESSAGE: FeedOpen message received before successful Handshake.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3784,7 +3784,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3797,8 +3797,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Handshake required." - } + Problem: "Handshake required.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3817,7 +3817,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3835,13 +3835,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated." + "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3857,7 +3857,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3870,8 +3870,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedOpen message." - } + Problem: "Unexpected FeedOpen message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3888,14 +3888,14 @@ describe("When the transport emits an invalid message event", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); const serverListener = harn.createServerListener(); const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3913,13 +3913,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated." + "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -3934,13 +3934,13 @@ describe("When the transport emits an invalid message event", () => { "some_tcid", "some_feed", { feed: "args" }, - { feed: "data" } + { feed: "data" }, ); const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3953,8 +3953,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedOpen message." - } + Problem: "Unexpected FeedOpen message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -3973,7 +3973,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -3991,13 +3991,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated." + "UNEXPECTED_MESSAGE: FeedOpen message referenced a feed that was not closed or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -4013,7 +4013,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedOpen", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4026,8 +4026,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedOpen message." - } + Problem: "Unexpected FeedOpen message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -4040,7 +4040,7 @@ describe("When the transport emits an invalid message event", () => { const harn = harness(); harn.makeServerStarted(); let cid; - harn.server.once("connect", c => { + harn.server.once("connect", (c) => { cid = c; }); harn.transport.emit("connect", "some_tcid"); @@ -4049,7 +4049,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4067,13 +4067,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedClose message received before successful Handshake." + "UNEXPECTED_MESSAGE: FeedClose message received before successful Handshake.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -4088,7 +4088,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4101,8 +4101,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Handshake required." - } + Problem: "Handshake required.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -4120,7 +4120,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4138,13 +4138,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated." + "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -4159,7 +4159,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4172,8 +4172,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedClose message." - } + Problem: "Unexpected FeedClose message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -4192,7 +4192,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4210,13 +4210,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated." + "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -4232,7 +4232,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4245,8 +4245,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedClose message." - } + Problem: "Unexpected FeedClose message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); }); @@ -4265,7 +4265,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4283,13 +4283,13 @@ describe("When the transport emits an invalid message event", () => { expect(serverListener.badClientMessage.mock.calls[0].length).toBe(2); expect(serverListener.badClientMessage.mock.calls[0][0]).toBe(cid); expect(serverListener.badClientMessage.mock.calls[0][1]).toBeInstanceOf( - Error + Error, ); expect(serverListener.badClientMessage.mock.calls[0][1].message).toBe( - "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated." + "UNEXPECTED_MESSAGE: FeedClose message referenced a feed that was not open or terminated.", ); expect( - serverListener.badClientMessage.mock.calls[0][1].clientMessage + serverListener.badClientMessage.mock.calls[0][1].clientMessage, ).toBe(msg); expect(serverListener.transportError.mock.calls.length).toBe(0); }); @@ -4305,7 +4305,7 @@ describe("When the transport emits an invalid message event", () => { const msg = JSON.stringify({ MessageType: "FeedClose", FeedName: "some_feed", - FeedArgs: { feed: "args" } + FeedArgs: { feed: "args" }, }); harn.transport.emit("message", "some_tcid", msg); @@ -4318,8 +4318,8 @@ describe("When the transport emits an invalid message event", () => { MessageType: "ViolationResponse", Diagnostics: { Message: msg, - Problem: "Unexpected FeedClose message." - } + Problem: "Unexpected FeedClose message.", + }, }); expect(harn.transport.disconnect.mock.calls.length).toBe(0); });