mqtt-plus 1.4.22 → 1.4.24

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" ])
+    })
 })
 

package/.ase/service.yaml

@@ -1 +0,0 @@
-port: 42082