mqtt-plus 1.4.0 → 1.4.2

package/src/mqtt-plus-timer.ts

@@ -0,0 +1,61 @@
+/*
+**  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.
+*/
+
+/*  internal requirements  */
+import type { APISchema }     from "./mqtt-plus-api"
+import { SubscriptionTrait }  from "./mqtt-plus-subscription"
+
+/*  Timer trait with reusable timer management  */
+export class TimerTrait<T extends APISchema = APISchema> extends SubscriptionTrait<T> {
+    /*  internal state  */
+    private timers = new Map<string, ReturnType<typeof setTimeout>>()
+
+    /*  destroy timer trait  */
+    override async destroy () {
+        for (const timer of this.timers.values())
+            clearTimeout(timer)
+        this.timers.clear()
+        await super.destroy()
+    }
+
+    /*  refresh (or start) a named timer  */
+    protected timerRefresh (id: string, onTimeout: () => void) {
+        const timer = this.timers.get(id)
+        if (timer !== undefined)
+            clearTimeout(timer)
+        this.timers.set(id, setTimeout(() => {
+            this.timers.delete(id)
+            onTimeout()
+        }, this.options.timeout))
+    }
+
+    /*  clear a named timer  */
+    protected timerClear (id: string) {
+        const timer = this.timers.get(id)
+        if (timer !== undefined) {
+            clearTimeout(timer)
+            this.timers.delete(id)
+        }
+    }
+}

package/src/mqtt-plus-trace.ts

@@ -38,6 +38,8 @@ class LogEvent {
         public msg:       string | Promise<string>,
         public data?:     Record<string, Promise<any> | any>
     ) {}
+
+    /*  resolve all pending promises in the log event  */
     async resolve () {
         if (this.msg instanceof Promise)
             this.msg = await this.msg.catch(() => "<resolve-failed>")
@@ -46,6 +48,8 @@ class LogEvent {
                 if (this.data[field] instanceof Promise)
                     this.data[field] = await this.data[field].catch(() => "<resolve-failed>")
     }
+
+    /*  render log event as string  */
     toString () {
         /*  render time  */
         const timestamp = new Date(this.timestamp)

package/src/mqtt-plus-util.ts

@@ -28,86 +28,6 @@ import { Readable }                     from "node:stream"
 
 /*  external requirements  */
 import PLazy                            from "p-lazy"
-import type { IClientSubscribeOptions } from "mqtt"
-
-/*  reference-counted subscription helper  */
-export class RefCountedSubscription {
-    private counts  = new Map<string, number>()
-    private pending = new Map<string, Promise<void>>()
-    private lingers = new Map<string, ReturnType<typeof setTimeout>>()
-    constructor (
-        private subscribeFn:   (topic: string, options: IClientSubscribeOptions) => Promise<void>,
-        private unsubscribeFn: (topic: string) => Promise<void>,
-        private lingerMs:      number = 30 * 1000
-    ) {}
-    async subscribe (topic: string, options: IClientSubscribeOptions = { qos: 2 }): Promise<void> {
-        /*  increment count first to reserve our interest  */
-        const count = this.counts.get(topic) ?? 0
-        this.counts.set(topic, count + 1)
-
-        /*  optionally just cancel a pending linger unsubscription
-            (subscription is still kept active on the broker)  */
-        const linger = this.lingers.get(topic)
-        if (linger) {
-            clearTimeout(linger)
-            this.lingers.delete(topic)
-            return
-        }
-
-        /*  if we are the first, we must perform the actual subscription  */
-        if (count === 0) {
-            const promise = this.subscribeFn(topic, options).finally(() => {
-                this.pending.delete(topic)
-            }).catch((err: Error) => {
-                const count = this.counts.get(topic)
-                if (count) {
-                    if (count <= 1)
-                        this.counts.delete(topic)
-                    else
-                        this.counts.set(topic, count - 1)
-                }
-                throw err
-            })
-            this.pending.set(topic, promise)
-            return promise
-        }
-        else {
-            /*  perhaps still need to wait for a pending subscription  */
-            const pending = this.pending.get(topic)
-            if (pending)
-                return pending
-        }
-    }
-    async unsubscribe (topic: string): Promise<void> {
-        const count = this.counts.get(topic)
-        if (count) {
-            if (count <= 1) {
-                this.counts.delete(topic)
-                if (this.lingerMs > 0) {
-                    /*  defer the actual broker unsubscription  */
-                    const timer = setTimeout(() => {
-                        this.lingers.delete(topic)
-                        this.unsubscribeFn(topic).catch(() => {})
-                    }, this.lingerMs)
-                    this.lingers.set(topic, timer)
-                }
-                else
-                    await this.unsubscribeFn(topic).catch(() => {})
-            }
-            else
-                this.counts.set(topic, count - 1)
-        }
-    }
-    async flush (): Promise<void> {
-        /*  flush all pending linger timers and unsubscribe immediately  */
-        const topics = [ ...this.lingers.keys() ]
-        for (const topic of topics) {
-            clearTimeout(this.lingers.get(topic))
-            this.lingers.delete(topic)
-            await this.unsubscribeFn(topic).catch(() => {})
-        }
-    }
-}
 
 /*  credit-based flow control gate for chunk producers  */
 export class CreditGate {
@@ -166,7 +86,7 @@ export class CreditGate {
     }
 }
 
-/*  concatenate elements of an Uint8Array array  */
+/*  concatenate elements of a Uint8Array array  */
 function uint8ArrayConcat (arrays: Uint8Array[]) {
     const totalLength = arrays.reduce((acc, value) => acc + value.byteLength, 0)
     const result = new Uint8Array(totalLength)

package/src/mqtt-plus-version.ts

@@ -33,13 +33,6 @@ export const versionToNum = (str: string) => {
     return parseInt(m[1], 10) + minor / 100
 }
 
-/*  convert version number to string  */
-export const versionToStr = (num: number) => {
-    const intPart = Math.floor(num)
-    const decPart = Math.round((num - intPart) * 100)
-    return `${intPart.toFixed(0)}.${decPart.toFixed(0).padStart(2, "0")}`
-}
-
 /*  package version (string format, injected)  */
 declare const __VERSION__: string
 export const VERSION = __VERSION__

package/tst/mqtt-plus-0-fixture.ts

@@ -68,7 +68,7 @@ export const mochaHooks = {
         /*  connect with MQTT as client  */
         ctx.mqttC = MQTT.connect("mqtt://127.0.0.1:1883",
             { clientId: "client" })
-        ctx.apiC = new MQTTp<API>(ctx.mqttC, { id: "client", timeout: 1000 })
+        ctx.apiC = new MQTTp<API>(ctx.mqttC, { id: "client", timeout: 500 })
         await new Promise<void>((resolve, reject) => {
             ctx.mqttC.once("connect", ()           => { resolve() })
             ctx.mqttC.once("error",   (err: Error) => { reject(err) })
@@ -81,7 +81,7 @@ export const mochaHooks = {
         /*  connect with MQTT as server  */
         ctx.mqttS = MQTT.connect("mqtt://127.0.0.1:1883",
             { clientId: "server", username: "example", password: "example" })
-        ctx.apiS = new MQTTp<API>(ctx.mqttS, { id: "server", timeout: 1000 })
+        ctx.apiS = new MQTTp<API>(ctx.mqttS, { id: "server", timeout: 500 })
         await new Promise<void>((resolve, reject) => {
             ctx.mqttS.once("connect", ()           => { resolve() })
             ctx.mqttS.once("error",   (err: Error) => { reject(err) })

package/tst/mqtt-plus-0-mosquitto.ts

@@ -56,6 +56,7 @@ const ACL = textframe(`
     topic   write     example/server/+/source-fetch-request/+
     pattern read      example/server/+/source-fetch-response/%c
     pattern read      example/server/+/source-fetch-chunk/%c
+    topic   write     example/server/+/source-fetch-credit/+
 
     topic   read      example/client/+/source-fetch-request/any
     pattern read      example/client/+/source-fetch-request/%c
@@ -72,6 +73,7 @@ const ACL = textframe(`
     pattern read      example/client/+/sink-push-request/%c
     pattern write     example/client/+/sink-push-response/%c
     pattern read      example/client/+/sink-push-chunk/%c
+    pattern read      example/client/+/sink-push-credit/%c
 
     #   ==== server/authenticated ACL ====
 
@@ -105,6 +107,8 @@ const ACL = textframe(`
     pattern read      $share/server/example/server/+/source-fetch-request/%c
     topic   write     example/server/+/source-fetch-response/+
     topic   write     example/server/+/source-fetch-chunk/+
+    pattern read      example/server/+/source-fetch-credit/%c
+    pattern read      $share/server/example/server/+/source-fetch-credit/%c
 
     topic   write     example/client/+/source-fetch-request/+
     pattern read      example/client/+/source-fetch-response/%c
@@ -119,6 +123,7 @@ const ACL = textframe(`
     topic   write     example/server/+/sink-push-response/+
     pattern read      example/server/+/sink-push-chunk/%c
     pattern read      $share/default/example/server/+/sink-push-chunk/%c
+    topic   write     example/client/+/sink-push-credit/+
 
     topic   write     example/client/+/sink-push-request/+
     pattern read      example/client/+/sink-push-response/%c

package/tst/mqtt-plus-1-api.spec.ts

@@ -100,7 +100,7 @@ describe("MQTT+ API", function () {
 
         /*  trigger some log activity by emitting an event  */
         apiTmp.emit("example/server/sample", "test", 1)
-        await new Promise((resolve) => { setTimeout(resolve, 100) })
+        await new Promise((resolve) => { setTimeout(resolve, 10) })
 
         /*  verify log entries were captured  */
         expect(logEntries.length).to.be.greaterThan(0)

package/tst/mqtt-plus-2-event.spec.ts

@@ -41,7 +41,6 @@ describe("MQTT+ Event Emission", function () {
     /*  test case: Event Emission  */
     it("MQTT+ Event Emission", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  register to event  */
@@ -64,7 +63,6 @@ describe("MQTT+ Event Emission", function () {
     /*  test case: Event Emission (Object API)  */
     it("MQTT+ Event Emission (Object API)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  register event  */
@@ -93,7 +91,6 @@ describe("MQTT+ Event Emission", function () {
     /*  test case: Event Emission with Meta Information  */
     it("MQTT+ Event Emission (Meta Information)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  register event  */
@@ -122,9 +119,6 @@ describe("MQTT+ Event Emission", function () {
 
     /*  test case: Event Emission (Duplicate Registration)  */
     it("MQTT+ Event Emission (Duplicate Registration)", async function () {
-        /*  setup  */
-        this.timeout(1000)
-
         /*  register event  */
         const reg = await ctx.apiS.event("example/server/sample", () => {})
 

package/tst/mqtt-plus-3-service.spec.ts

@@ -41,7 +41,6 @@ describe("MQTT+ Service Call", function () {
     /*  test case: Service Call  */
     it("MQTT+ Service Call", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  provide service  */
@@ -82,7 +81,6 @@ describe("MQTT+ Service Call", function () {
     /*  test case: Service Call (Object API)  */
     it("MQTT+ Service Call (Object API)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  provide service  */
@@ -111,7 +109,6 @@ describe("MQTT+ Service Call", function () {
     /*  test case: Service Call (Meta Information)  */
     it("MQTT+ Service Call (Meta Information)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  provide service that checks metadata  */
@@ -142,7 +139,8 @@ describe("MQTT+ Service Call", function () {
 
     /*  test case: Service Call (Timeout)  */
     it("MQTT+ Service Call (Timeout)", async function () {
-        /*  setup (higher timeout for this test)  */
+        /*  setup (higher timeout for this particular test)  */
+        this.slow(2000)
         this.timeout(2000)
         const spy = sinon.spy()
 
@@ -160,7 +158,6 @@ describe("MQTT+ Service Call", function () {
     /*  test case: Service Call (Direct Receiver)  */
     it("MQTT+ Service Call (Direct Receiver)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  provide service on server  */
@@ -188,13 +185,12 @@ describe("MQTT+ Service Call", function () {
     /*  test case: Service Call (Async Handler)  */
     it("MQTT+ Service Call (Async Handler)", async function () {
         /*  setup  */
-        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  provide async service  */
         const registration = await ctx.apiS.service("example/server/login", async (password: string) => {
             spy("service")
-            await new Promise((resolve) => { setTimeout(resolve, 50) })
+            await new Promise((resolve) => { setTimeout(resolve, 0) })
             if (password !== "secret")
                 throw new Error("invalid password")
             return "token-abc"

package/tst/mqtt-plus-4-sink.spec.ts

@@ -45,7 +45,9 @@ const { expect } = chai
 describe("MQTT+ Sink Push", function () {
     /*  test case: Sink Push (Buffer)  */
     it("MQTT+ Sink Push (Buffer)", async function () {
-        this.timeout(2000)
+        /*  setup  */
+        this.slow(1000)
+        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  generate random data  */
@@ -61,7 +63,7 @@ describe("MQTT+ Sink Push", function () {
             info.buffer!.then((buf: Uint8Array) => {
                 spy("buffer")
                 expect(Buffer.from(buf)).to.deep.equal(data)
-            })
+            }).catch(() => {})
         })
 
         /*  push a buffer (instead of a stream)  */
@@ -70,7 +72,7 @@ describe("MQTT+ Sink Push", function () {
         }).catch((err: Error) => {
             spy("push-error")
         })
-        await new Promise((resolve) => { setTimeout(resolve, 1000) })
+        await new Promise((resolve) => { setTimeout(resolve, 100) })
         expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.same.deep.members([ "sink", "push-success", "buffer" ])
 
@@ -81,7 +83,8 @@ describe("MQTT+ Sink Push", function () {
     /*  test case: Sink Push (Stream)  */
     it("MQTT+ Sink Push (Stream)", async function () {
         /*  setup  */
-        this.timeout(2000)
+        this.slow(1000)
+        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  generate random data  */
@@ -93,7 +96,7 @@ describe("MQTT+ Sink Push", function () {
             if (name !== "foo")
                 throw new Error("invalid sink push")
             expect(name).to.be.equal("foo")
-            expect(info).to.be.of.an("object")
+            expect(info).to.be.an("object")
             expect(info.stream).to.be.instanceOf(stream.Readable)
             const chunks: Buffer[] = []
             info.stream!.on("data", (chunk: Buffer) => {
@@ -117,7 +120,7 @@ describe("MQTT+ Sink Push", function () {
         }).catch((err: Error) => {
             spy("transfer-error")
         })
-        await new Promise((resolve) => { setTimeout(resolve, 1000) })
+        await new Promise((resolve) => { setTimeout(resolve, 100) })
         expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.same.deep.members([ "sink", "transfer-success", "end" ])
 
@@ -127,7 +130,9 @@ describe("MQTT+ Sink Push", function () {
 
     /*  test case: Sink Push (Meta Information)  */
     it("MQTT+ Sink Push (Meta Information)", async function () {
-        this.timeout(2000)
+        /*  setup  */
+        this.slow(1000)
+        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  set instance-level meta on client  */
@@ -148,7 +153,7 @@ describe("MQTT+ Sink Push", function () {
             info.buffer!.then((buf: Uint8Array) => {
                 spy("buffer")
                 expect(Buffer.from(buf)).to.deep.equal(data)
-            })
+            }).catch(() => {})
         })
 
         /*  push with metadata  */
@@ -162,7 +167,7 @@ describe("MQTT+ Sink Push", function () {
         }).catch((err: Error) => {
             spy("push-error")
         })
-        await new Promise((resolve) => { setTimeout(resolve, 1000) })
+        await new Promise((resolve) => { setTimeout(resolve, 100) })
         expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.same.deep.members([ "sink", "push-success", "buffer" ])
 

package/tst/mqtt-plus-5-source.spec.ts

@@ -41,7 +41,9 @@ const { expect } = chai
 describe("MQTT+ Source Fetch", function () {
     /*  test case: Source Fetch (Buffer)  */
     it("MQTT+ Source Fetch (Buffer)", async function () {
-        this.timeout(3000)
+        /*  setup  */
+        this.slow(2000)
+        this.timeout(2000)
 
         /*  establish source  */
         const sourcing = await ctx.apiS.source("example/server/download", async (filename, info) => {
@@ -65,7 +67,7 @@ describe("MQTT+ Source Fetch", function () {
         expect(error2).to.be.equal("invalid source")
 
         /*  fetch non-existing source (invalid source name)  */
-        const result3 = await ctx.apiC.fetch("example/server/download-invalid", "foo").catch((err) => err.message)
+        const result3 = await ctx.apiC.fetch("example/server/download-invalid", "foo")
         const error3 = await result3.buffer.catch((err: Error) => {
             return err.message
         })
@@ -76,7 +78,9 @@ describe("MQTT+ Source Fetch", function () {
 
     /*  test case: Source Fetch (Stream)  */
     it("MQTT+ Source Fetch (Stream)", async function () {
-        this.timeout(3000)
+        /*  setup  */
+        this.slow(1000)
+        this.timeout(1000)
 
         /*  establish source providing data via stream  */
         const sourcing = await ctx.apiS.source("example/server/download", async (filename, info) => {
@@ -104,13 +108,15 @@ describe("MQTT+ Source Fetch", function () {
 
     /*  test case: Source Fetch (Meta Information)  */
     it("MQTT+ Source Fetch (Meta Information)", async function () {
+        /*  setup  */
+        this.slow(1000)
         this.timeout(1000)
 
         /*  set instance-level meta on server  */
         ctx.apiS.meta("server-version", "1.0")
 
         /*  establish source  */
-        const sourcing = await ctx.apiS.source("example/server/download", async (filename, info) => {
+        const sourcing = await ctx.apiS.source("example/server/download", async (_filename, info) => {
             info.buffer = Promise.resolve(Buffer.from("data"))
         })
 
@@ -121,7 +127,7 @@ describe("MQTT+ Source Fetch", function () {
         expect(meta!["server-version"]).to.be.equal("1.0")
 
         /*  cleanup  */
-        ctx.apiS.meta("server-version", undefined)
+        ctx.apiS.meta("server-version", null)
         await sourcing.destroy()
     })
 })

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

@@ -46,9 +46,11 @@ const { expect } = chai
 
 /*  test suite  */
 describe("MQTT+ Miscellaneous", function () {
-    /*  test case: Dry-Run & Last-Will */
+    /*  test case: Dry-Run & Last-Will  */
     it("MQTT+ Dry-Run & MQTT Last-Will", async function () {
-        this.timeout(3000)
+        /*  setup  */
+        this.slow(2000)
+        this.timeout(2000)
 
         /*  generate connection close event  */
         const mqttpDry = new MQTTp<API>(null, { id: "my-client" })
@@ -63,11 +65,11 @@ describe("MQTT+ Miscellaneous", function () {
             mqttServer.once("connect", ()           => { resolve() })
             mqttServer.once("error",   (err: Error) => { reject(err) })
         })
-        const apiServer = new MQTTp<API>(mqttServer, { timeout: 1000 })
+        const apiServer = new MQTTp<API>(mqttServer, { timeout: 100 })
 
         /*  observe connection events  */
         const spy = sinon.spy()
-        apiServer.event("example/server/connection", (state) => {
+        const eventReg = await apiServer.event("example/server/connection", (state) => {
             expect(state).to.match(/^(?:open|close)$/)
             spy(state)
         })
@@ -84,7 +86,7 @@ describe("MQTT+ Miscellaneous", function () {
             mqttClient.once("connect", ()           => { resolve() })
             mqttClient.once("error",   (err: Error) => { reject(err) })
         })
-        const apiClient = new MQTTp<API>(mqttClient, { timeout: 1000 })
+        const apiClient = new MQTTp<API>(mqttClient, { timeout: 100 })
 
         /*  send connection open event  */
         await apiClient.emit("example/server/connection", "open")
@@ -93,11 +95,12 @@ describe("MQTT+ Miscellaneous", function () {
         /*  perform unexpected destruction of client  */
         apiClient.destroy()
         mqttClient.end(true)
-        await new Promise((resolve) => { setTimeout(resolve, 1000) })
+        await new Promise((resolve) => { setTimeout(resolve, 100) })
 
         /*  perform regular destruction of client  */
+        await eventReg.destroy()
         apiServer.destroy()
-        mqttServer.end()
+        await mqttServer.endAsync()
 
         /*  ensure connection open and close events were seen  */
         expect(spy.getCalls().map((call) => call.firstArg))
@@ -107,7 +110,8 @@ describe("MQTT+ Miscellaneous", function () {
     /*  test case: Authentication  */
     it("MQTT+ Authentication", async function () {
         /*  setup  */
-        this.timeout(3000)
+        this.slow(1000)
+        this.timeout(1000)
         const spy = sinon.spy()
 
         /*  credentials  */
@@ -141,13 +145,12 @@ describe("MQTT+ Miscellaneous", function () {
         })
 
         /*  call service (without token)  */
-        await ctx.apiC.call("example/server/hello", "world", 42).then(async (result) => {
+        await ctx.apiC.call("example/server/hello", "world", 42).then(async (_result) => {
             spy("call1-success")
-        }).catch((err: Error) => {
+        }).catch((_err: Error) => {
             spy("call1-error")
         })
-        expect(spy.getCalls()
-            .map((call) => call.firstArg))
+        expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.deep.equal([ "call1-error" ])
         spy.resetHistory()
 
@@ -155,35 +158,32 @@ describe("MQTT+ Miscellaneous", function () {
         await ctx.apiC.call("example/server/login", userCred).then(async (token) => {
             spy("login-success")
             expect(token).to.be.equal(userToken)
-        }).catch((err: Error) => {
+        }).catch((_err: Error) => {
             spy("login-error")
         })
-        expect(spy.getCalls()
-            .map((call) => call.firstArg))
+        expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.deep.equal([ "login", "login-success" ])
         spy.resetHistory()
 
         /*  call service (with wrong token)  */
         await ctx.apiC.authenticate("wrong")
-        await ctx.apiC.call("example/server/hello", "world", 42).then(async (result) => {
+        await ctx.apiC.call("example/server/hello", "world", 42).then(async (_result) => {
             spy("call2-success")
-        }).catch((err: Error) => {
+        }).catch((_err: Error) => {
             spy("call2-error")
         })
-        expect(spy.getCalls()
-            .map((call) => call.firstArg))
+        expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.deep.equal([ "call2-error" ])
         spy.resetHistory()
 
         /*  call service (with correct token)  */
         await ctx.apiC.authenticate(userToken)
-        await ctx.apiC.call("example/server/hello", "world", 42).then(async (result) => {
+        await ctx.apiC.call("example/server/hello", "world", 42).then(async (_result) => {
             spy("call3-success")
-        }).catch((err: Error) => {
+        }).catch((_err: Error) => {
             spy("call3-error")
         })
-        expect(spy.getCalls()
-            .map((call) => call.firstArg))
+        expect(spy.getCalls().map((call) => call.firstArg))
             .to.be.deep.equal([ "hello", "call3-success" ])
 
         /*  destroy service  */

package/tst/tsc.json

@@ -22,7 +22,7 @@
         }
     },
     "include": [
-        "../tst/**/*.spec.ts"
+        "*.ts"
     ],
     "exclude": [
         "../node_modules"