mqtt-plus 1.4.23 → 1.4.25

package/tst/mqtt-plus-6-misc.spec.ts

@@ -36,6 +36,7 @@ import MQTT                 from "mqtt"
 
 /*  internal dependencies  */
 import MQTTp                from "mqtt-plus"
+import type { Event }       from "mqtt-plus"
 import { ctx }              from "./mqtt-plus-0-fixture"
 import type { API }         from "./mqtt-plus-0-fixture"
 import { makeMutuallyExclusiveFields } from "../src/mqtt-plus-util"
@@ -113,31 +114,76 @@ describe("MQTT+ Miscellaneous", function () {
         /*  setup  */
         this.slow(2000)
         this.timeout(2000)
-        const spy = sinon.spy()
+        const spy  = sinon.spy()
+        const spyB = sinon.spy()
 
         /*  create JSON codec API instances on existing MQTT connections  */
-        const apiJsonS = new MQTTp<API>(ctx.mqttS, { id: "json-server", codec: "json", timeout: 500 })
-        const apiJsonC = new MQTTp<API>(ctx.mqttC, { id: "json-client", codec: "json", timeout: 500 })
+        type APIX = API & { "example/server/binary": Event<(data: Buffer) => void> }
+        const apiJsonS = new MQTTp<APIX>(ctx.mqttS, { id: "json-server", codec: "json", timeout: 500 })
+        const apiJsonC = new MQTTp<APIX>(ctx.mqttC, { id: "json-client", codec: "json", timeout: 500 })
 
-        /*  register event handler  */
+        /*  register event handlers  */
         const registration = await apiJsonS.event("example/server/sample", (str: string, num: number) => {
             spy("event", str, num)
         })
+        const registrationB = await apiJsonS.event("example/server/binary", (data: Buffer) => {
+            spyB(data)
+        })
 
-        /*  emit event via JSON codec  */
+        /*  emit events via JSON codec  */
         apiJsonC.emit("example/server/sample", "hello", 99)
+        apiJsonC.emit("example/server/binary", Buffer.from([ 0x01, 0x02, 0x03, 0xff ]))
         await new Promise((resolve) => { setTimeout(resolve, 100) })
 
         /*  verify round-trip  */
         expect(spy.getCalls().length).to.equal(1)
         expect(spy.getCalls()[0].args).to.deep.equal([ "event", "hello", 99 ])
 
+        /*  verify Buffer round-trip  */
+        expect(spyB.getCalls().length).to.equal(1)
+        const data: Buffer = spyB.getCalls()[0].args[0]
+        expect(data).to.be.instanceOf(Buffer)
+        expect(data.equals(Buffer.from([ 0x01, 0x02, 0x03, 0xff ]))).to.equal(true)
+
         /*  cleanup  */
         await registration.destroy()
+        await registrationB.destroy()
         apiJsonS.destroy()
         apiJsonC.destroy()
     })
 
+    /*  test case: Error Event on throwing topicMatch  */
+    it("MQTT+ Error Event on Throwing topicMatch", async function () {
+        /*  setup  */
+        this.slow(2000)
+        this.timeout(2000)
+        const spy = sinon.spy()
+
+        /*  create API instances with a throwing user-supplied topicMatch on the receiver side  */
+        const apiThrowS = new MQTTp<API>(ctx.mqttS, { id: "throw-server", timeout: 500,
+            topicMatch: () => { throw new Error("intentionally failing topicMatch") } })
+        const apiThrowC = new MQTTp<API>(ctx.mqttC, { id: "throw-client", timeout: 500 })
+
+        /*  observe MQTT+ error events  */
+        apiThrowS.on("error", (err: Error) => { spy(err.message) })
+
+        /*  register event handler to subscribe the topic  */
+        const registration = await apiThrowS.event("example/server/sample", () => {})
+
+        /*  emit event to trigger the inbound message processing  */
+        apiThrowC.emit("example/server/sample", "hello", 42)
+        await new Promise((resolve) => { setTimeout(resolve, 100) })
+
+        /*  ensure the exception surfaced as MQTT+ "error" event  */
+        expect(spy.getCalls().length).to.be.at.least(1)
+        expect(spy.getCalls()[0].args[0]).to.match(/failed to match MQTT topic/)
+
+        /*  cleanup  */
+        await registration.destroy()
+        apiThrowS.destroy()
+        apiThrowC.destroy()
+    })
+
     /*  test case: Authentication  */
     it("MQTT+ Authentication", async function () {
         /*  setup  */
@@ -222,6 +268,37 @@ describe("MQTT+ Miscellaneous", function () {
         await registration2.destroy()
     })
 
+    /*  test case: Authentication with Empty Role  */
+    it("MQTT+ Authentication with Empty Role", async function () {
+        /*  setup  */
+        this.slow(2000)
+        this.timeout(2000)
+        const spy = sinon.spy()
+
+        /*  server-side: provide hello service with falsy-but-valid empty role  */
+        const registration = await ctx.apiS.service({
+            name: "example/server/hello",
+            auth: "",
+            callback: (str: string, num: number) => {
+                spy("hello")
+                return `${str}:${num}`
+            }
+        })
+
+        /*  call service and expect fail-closed rejection  */
+        await ctx.apiC.call("example/server/hello", "world", 42).then(async (_result) => {
+            spy("call-success")
+        }).catch((err: Error) => {
+            spy("call-error")
+            expect(err.message).to.match(/failed authentication/)
+        })
+        expect(spy.getCalls().map((call) => call.firstArg))
+            .to.be.deep.equal([ "call-error" ])
+
+        /*  cleanup  */
+        await registration.destroy()
+    })
+
     /*  test case: Unit: arr2buf/buf2arr  */
     it("MQTT+ Unit: arr2buf/buf2arr", function () {
         /*  create a dry-run MQTTp instance for accessing encode methods  */

package/tst/mqtt-plus-8-run.spec.ts

@@ -81,6 +81,23 @@ describe("MQTT+ Run", function () {
         }
     })
 
+    /*  test case: MQTT+ Run: async oncatch recovers but onfinally fails invokes onfinally once  */
+    it("MQTT+ Run: async oncatch recovers but onfinally fails invokes onfinally once", async function () {
+        let finallyCount = 0
+        try {
+            await run(
+                () => Promise.reject(new Error("async-fail")),
+                (_err: Error) => Promise.resolve("async-recovered"),
+                async () => { finallyCount++; throw new Error("onfinally-fail") }
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/onfinally-fail/)
+        }
+        expect(finallyCount).to.equal(1)
+    })
+
     /*  test case: MQTT+ Run: sync success with spool and oncleanup  */
     it("MQTT+ Run: sync success with spool and oncleanup", function () {
         const spool = new Spool()
@@ -96,6 +113,36 @@ describe("MQTT+ Run", function () {
         expect(cleanups).to.deep.equal([ "resource-val" ])
     })
 
+    /*  test case: MQTT+ Run: sync oncatch recovery with spool and oncleanup  */
+    it("MQTT+ Run: sync oncatch recovery with spool and oncleanup", function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        run<string, string>(
+            spool,
+            () => { throw new Error("fail") },
+            (_err: Error) => "recovered-val",
+            undefined,
+            (val: string) => { cleanups.push(val) }
+        )
+        spool.unroll()
+        expect(cleanups).to.deep.equal([ "recovered-val" ])
+    })
+
+    /*  test case: MQTT+ Run: async oncatch recovery with spool and oncleanup  */
+    it("MQTT+ Run: async oncatch recovery with spool and oncleanup", async function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        await run<string, Promise<string>>(
+            spool,
+            () => Promise.reject(new Error("async-fail")),
+            (_err: Error) => Promise.resolve("async-recovered-val"),
+            undefined,
+            async (val: string) => { cleanups.push(val) }
+        )
+        await spool.unroll()
+        expect(cleanups).to.deep.equal([ "async-recovered-val" ])
+    })
+
     /*  test case: MQTT+ Run: oncleanup without spool throws  */
     it("MQTT+ Run: oncleanup without spool throws", function () {
         try {
@@ -111,5 +158,65 @@ describe("MQTT+ Run", function () {
             expect(err.message).to.equal("oncleanup requires a spool")
         }
     })
+
+    /*  test case: MQTT+ Run: sync error with throwing onfinally still unrolls and preserves error  */
+    it("MQTT+ Run: sync error with throwing onfinally still unrolls and preserves error", function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        spool.roll("res", (val: unknown) => { cleanups.push(val as string) })
+        try {
+            run<string, string>(
+                spool,
+                () => { throw new Error("action-fail") },
+                undefined,
+                () => { throw new Error("finally-fail") }
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/action-fail/)
+        }
+        expect(cleanups).to.deep.equal([ "res" ])
+    })
+
+    /*  test case: MQTT+ Run: async error with rejecting onfinally still unrolls and preserves error  */
+    it("MQTT+ Run: async error with rejecting onfinally still unrolls and preserves error", async function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        spool.roll("res", (val: unknown) => { cleanups.push(val as string) })
+        try {
+            await run<string, Promise<string>>(
+                spool,
+                () => Promise.reject(new Error("async-action-fail")),
+                undefined,
+                () => Promise.reject(new Error("async-finally-fail"))
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/async-action-fail/)
+        }
+        expect(cleanups).to.deep.equal([ "res" ])
+    })
+
+    /*  test case: MQTT+ Run: async success with rejecting onfinally surfaces onfinally error but still cleans up  */
+    it("MQTT+ Run: async success with rejecting onfinally surfaces onfinally error but still cleans up", async function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        try {
+            await run<string, Promise<string>>(
+                spool,
+                () => Promise.resolve("resource-val"),
+                undefined,
+                () => Promise.reject(new Error("finally-fail")),
+                async (val: string) => { cleanups.push(val) }
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/finally-fail/)
+        }
+        expect(cleanups).to.deep.equal([ "resource-val" ])
+    })
 })