mqtt-plus 1.4.13 → 1.4.15

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

@@ -38,6 +38,7 @@ import MQTT                 from "mqtt"
 import MQTTp                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"
 
 /*  setup test suite infrastructure  */
 chai.config.includeStack = true
@@ -107,11 +108,41 @@ describe("MQTT+ Miscellaneous", function () {
             .to.be.deep.equal([ "open", "close" ])
     })
 
+    /*  test case: JSON Codec  */
+    it("MQTT+ JSON Codec", async function () {
+        /*  setup  */
+        this.slow(2000)
+        this.timeout(2000)
+        const spy = 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 })
+
+        /*  register event handler  */
+        const registration = await apiJsonS.event("example/server/sample", (str: string, num: number) => {
+            spy("event", str, num)
+        })
+
+        /*  emit event via JSON codec  */
+        apiJsonC.emit("example/server/sample", "hello", 99)
+        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 ])
+
+        /*  cleanup  */
+        await registration.destroy()
+        apiJsonS.destroy()
+        apiJsonC.destroy()
+    })
+
     /*  test case: Authentication  */
     it("MQTT+ Authentication", async function () {
         /*  setup  */
-        this.slow(1000)
-        this.timeout(1000)
+        this.slow(4000)
+        this.timeout(4000)
         const spy = sinon.spy()
 
         /*  credentials  */
@@ -190,5 +221,51 @@ describe("MQTT+ Miscellaneous", function () {
         await registration.destroy()
         await registration2.destroy()
     })
+
+    /*  test case: Unit: arr2buf/buf2arr  */
+    it("MQTT+ Unit: arr2buf/buf2arr", function () {
+        /*  create a dry-run MQTTp instance for accessing encode methods  */
+        const mqttp = new MQTTp(null)
+
+        /*  arr2buf with Int8Array  */
+        const src = new Int8Array([ 1, -2, 3 ])
+        const buf = mqttp.arr2buf(src)
+        expect(buf).to.be.instanceOf(Uint8Array)
+        expect(buf.byteLength).to.equal(3)
+
+        /*  arr2buf with Buffer  */
+        const src2 = Buffer.from([ 10, 20, 30 ])
+        const buf2 = mqttp.arr2buf(src2)
+        expect(buf2).to.be.instanceOf(Uint8Array)
+        expect(buf2.byteLength).to.equal(3)
+
+        /*  buf2arr with Int8Array  */
+        const src3 = new Uint8Array([ 1, 2, 3 ])
+        const arr = mqttp.buf2arr(src3, Int8Array)
+        expect(arr).to.be.instanceOf(Int8Array)
+        expect(arr.byteLength).to.equal(3)
+
+        /*  buf2arr with Float32Array throws  */
+        const src4 = new Uint8Array([ 1, 2, 3, 4 ])
+        expect(() => mqttp.buf2arr(src4, Float32Array as any)).to.throw("invalid data type")
+
+        /*  cleanup  */
+        mqttp.destroy()
+    })
+
+    /*  test case: Unit: makeMutuallyExclusiveFields  */
+    it("MQTT+ Unit: makeMutuallyExclusiveFields", function () {
+        /*  accessing f1 after f2 consumed throws  */
+        const obj1 = { a: 1, b: 2 }
+        makeMutuallyExclusiveFields(obj1, "a", "b")
+        void obj1.b
+        expect(() => obj1.a).to.throw(/mutually exclusive/)
+
+        /*  accessing f2 after f1 consumed throws  */
+        const obj2 = { a: 1, b: 2 }
+        makeMutuallyExclusiveFields(obj2, "a", "b")
+        void obj2.a
+        expect(() => obj2.b).to.throw(/mutually exclusive/)
+    })
 })
 

package/tst/mqtt-plus-7-spool.spec.ts

@@ -0,0 +1,101 @@
+/*
+**  MQTT+ -- MQTT Communication Patterns
+**  Copyright (c) 2018-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**
+**  Permission is hereby granted, free of charge, to any person obtaining
+**  a copy of this software and associated documentation files (the
+**  "Software"), to deal in the Software without restriction, including
+**  without limitation the rights to use, copy, modify, merge, publish,
+**  distribute, sublicense, and/or sell copies of the Software, and to
+**  permit persons to whom the Software is furnished to do so, subject to
+**  the following conditions:
+**
+**  The above copyright notice and this permission notice shall be included
+**  in all copies or substantial portions of the Software.
+**
+**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+**  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+**  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+**  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+**  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+**  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+**  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/*  external dependencies (test suite)  */
+import { describe, it }  from "mocha"
+import * as chai         from "chai"
+
+/*  internal dependencies  */
+import { Spool }         from "../src/mqtt-plus-error"
+
+/*  setup test suite infrastructure  */
+chai.config.includeStack = true
+const { expect } = chai
+
+/*  test suite  */
+describe("MQTT+ Spool", function () {
+    /*  test case: Spool: unroll runs multiple async cleanups in reverse order  */
+    it("MQTT+ Spool: unroll chains multiple async cleanups in reverse order", async function () {
+        const order: number[] = []
+        const spool = new Spool()
+        spool.roll(() => { order.push(1) })
+        spool.roll(() => { order.push(2) })
+        spool.roll(() => Promise.resolve().then(() => { order.push(3) }))
+        await spool.unroll()
+        expect(order).to.deep.equal([ 3, 2, 1 ])
+    })
+
+    /*  test case: Spool: unroll with suppress swallows rejected promise  */
+    it("MQTT+ Spool: unroll with suppress swallows rejected promise", async function () {
+        const spool = new Spool()
+        spool.roll(() => Promise.reject(new Error("boom")))
+        await spool.unroll()
+    })
+
+    /*  test case: Spool: unroll with suppress propagates rejected promise  */
+    it("MQTT+ Spool: unroll propagates rejected promise", async function () {
+        const spool = new Spool()
+        spool.roll(() => Promise.reject(new Error("boom")))
+        try {
+            await spool.unroll(false)
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.equal("boom")
+        }
+    })
+
+    /*  test case: Spool: unroll with suppress swallows synchronous throw  */
+    it("MQTT+ Spool: unroll with suppress swallows synchronous throw", function () {
+        const spool = new Spool()
+        spool.roll(() => { throw new Error("sync boom") })
+        spool.unroll()
+    })
+
+    /*  test case: Spool: unroll re-throws synchronous error  */
+    it("MQTT+ Spool: unroll re-throws synchronous error", function () {
+        const spool = new Spool()
+        spool.roll(() => { throw new Error("sync boom") })
+        try {
+            spool.unroll(false)
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.equal("sync boom")
+        }
+    })
+
+    /*  test case: Spool: sub-spool is unrolled recursively  */
+    it("MQTT+ Spool: sub-spool is unrolled recursively", async function () {
+        const order: string[] = []
+        const spool = new Spool()
+        spool.roll(() => { order.push("outer-1") })
+        const sub = spool.sub()
+        sub.roll(() => { order.push("inner-1") })
+        sub.roll(() => Promise.resolve().then(() => { order.push("inner-2") }))
+        spool.roll(() => { order.push("outer-2") })
+        await spool.unroll()
+        expect(order).to.deep.equal([ "outer-2", "inner-2", "inner-1", "outer-1" ])
+    })
+})

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

@@ -0,0 +1,115 @@
+/*
+**  MQTT+ -- MQTT Communication Patterns
+**  Copyright (c) 2018-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**
+**  Permission is hereby granted, free of charge, to any person obtaining
+**  a copy of this software and associated documentation files (the
+**  "Software"), to deal in the Software without restriction, including
+**  without limitation the rights to use, copy, modify, merge, publish,
+**  distribute, sublicense, and/or sell copies of the Software, and to
+**  permit persons to whom the Software is furnished to do so, subject to
+**  the following conditions:
+**
+**  The above copyright notice and this permission notice shall be included
+**  in all copies or substantial portions of the Software.
+**
+**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+**  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+**  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+**  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+**  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+**  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+**  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/*  external dependencies (test suite)  */
+import { describe, it }   from "mocha"
+import * as chai          from "chai"
+
+/*  internal dependencies  */
+import { Spool, run }     from "../src/mqtt-plus-error"
+
+/*  setup test suite infrastructure  */
+chai.config.includeStack = true
+const { expect } = chai
+
+/*  test suite  */
+describe("MQTT+ Run", function () {
+    /*  test case: MQTT+ Run: sync action throws and oncatch recovers  */
+    it("MQTT+ Run: sync action throws and oncatch recovers", function () {
+        const result = run(
+            () => { throw new Error("fail") },
+            (_err: Error) => "recovered"
+        )
+        expect(result).to.equal("recovered")
+    })
+
+    /*  test case: MQTT+ Run: sync action throws and oncatch also throws  */
+    it("MQTT+ Run: sync action throws and oncatch also throws", function () {
+        try {
+            run(
+                () => { throw new Error("fail") },
+                (_err: Error) => { throw new Error("oncatch-fail") }
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/oncatch-fail/)
+        }
+    })
+
+    /*  test case: MQTT+ Run: async action rejects and oncatch recovers  */
+    it("MQTT+ Run: async action rejects and oncatch recovers", async function () {
+        const result = await run(
+            () => Promise.reject(new Error("async-fail")),
+            (_err: Error) => Promise.resolve("async-recovered")
+        )
+        expect(result).to.equal("async-recovered")
+    })
+
+    /*  test case: MQTT+ Run: async action rejects and oncatch also throws  */
+    it("MQTT+ Run: async action rejects and oncatch also throws", async function () {
+        try {
+            await run(
+                () => Promise.reject(new Error("async-fail")),
+                (_err: Error) => { throw new Error("oncatch-async-fail") }
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.match(/oncatch-async-fail/)
+        }
+    })
+
+    /*  test case: MQTT+ Run: sync success with spool and oncleanup  */
+    it("MQTT+ Run: sync success with spool and oncleanup", function () {
+        const spool = new Spool()
+        const cleanups: string[] = []
+        run<string, string>(
+            spool,
+            () => "resource-val",
+            undefined,
+            undefined,
+            (val: string) => { cleanups.push(val) }
+        )
+        spool.unroll()
+        expect(cleanups).to.deep.equal([ "resource-val" ])
+    })
+
+    /*  test case: MQTT+ Run: oncleanup without spool throws  */
+    it("MQTT+ Run: oncleanup without spool throws", function () {
+        try {
+            run(
+                () => "ok",
+                undefined,
+                undefined,
+                (_val: string) => {}
+            )
+            expect.fail("should have thrown")
+        }
+        catch (err: any) {
+            expect(err.message).to.equal("oncleanup requires a spool")
+        }
+    })
+})
+

package/tst/{tsc.json → tsc.cov.json}

@@ -11,14 +11,15 @@
         "resolveJsonModule":       false,
         "isolatedModules":         false,
         "esModuleInterop":         false,
-        "lib":                     [ "es2022", "dom" ],
+        "lib":                     [ "es2022" ],
         "skipLibCheck":            true,
         "declaration":             true,
         "noEmit":                  true,
-        "rootDir":                 "../tst",
+        "allowImportingTsExtensions": true,
+        "rootDir":                 "..",
         "baseUrl":                 "..",
         "paths": {
-            "mqtt-plus":           [ "dst-stage1/mqtt-plus.d.ts" ]
+            "mqtt-plus": [ "src/mqtt-plus" ]
         }
     },
     "include": [

package/tst/tsc.std.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "outDir":                  "../dst-stage1",
+        "target":                  "es2022",
+        "module":                  "ESNext",
+        "moduleResolution":        "Bundler",
+        "useDefineForClassFields": false,
+        "composite":               false,
+        "strict":                  true,
+        "strictFunctionTypes":     true,
+        "resolveJsonModule":       false,
+        "isolatedModules":         false,
+        "esModuleInterop":         false,
+        "lib":                     [ "es2022" ],
+        "skipLibCheck":            true,
+        "declaration":             true,
+        "noEmit":                  true,
+        "allowImportingTsExtensions": true,
+        "rootDir":                 "..",
+        "baseUrl":                 "..",
+        "paths": {
+            "mqtt-plus": [ "dst-stage1/mqtt-plus" ]
+        }
+    },
+    "include": [
+        "*.ts"
+    ],
+    "exclude": [
+        "../node_modules"
+    ]
+}