@seriousme/opifex 1.11.3 → 2.1.0

package/client/handlers/handleSuback.test.ts

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleSuback } from "./handleSuback.ts";
+import { PacketType } from "../deps.ts";
+import type { SubackPacket } from "../deps.ts";
+
+function createMockContext() {
+  const receivedSubacks: Array<{ id: number; returnCodes: number[] }> = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map(),
+    },
+    receiveSuback: (id: number, returnCodes: number[]) => {
+      receivedSubacks.push({ id, returnCodes });
+      return true;
+    },
+    receivedSubacks,
+  };
+}
+
+test("handleSuback removes from pending and notifies context", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.subscribe, id: 1 });
+
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 4 as const,
+    id: 1,
+    returnCodes: [0],
+  } as SubackPacket;
+
+  handleSuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(1),
+    false,
+    "Should remove from pending",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedSubacks.length,
+    1,
+    "Should notify context",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedSubacks[0].id,
+    1,
+    "Should have correct ID",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedSubacks[0].returnCodes,
+    [0],
+    "Should pass return codes",
+  );
+});
+
+test("handleSuback handles multiple return codes", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.subscribe, id: 2 });
+
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 4 as const,
+    id: 2,
+    returnCodes: [0, 1, 2],
+  } as SubackPacket;
+
+  handleSuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedSubacks[0].returnCodes,
+    [0, 1, 2],
+  );
+});
+
+test("handleSuback handles subscription failure code", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(3, { type: PacketType.subscribe, id: 3 });
+
+  const SUBSCRIPTION_FAILURE = 0x80;
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 4 as const,
+    id: 3,
+    returnCodes: [0, SUBSCRIPTION_FAILURE],
+  } as SubackPacket;
+
+  handleSuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedSubacks[0].returnCodes,
+    [0, SUBSCRIPTION_FAILURE],
+  );
+});
+
+test("handleSuback handles notification for MQTT v5", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(4, { type: PacketType.subscribe, id: 4 });
+
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 5 as const,
+    id: 4,
+    reasonCodes: [0],
+  } as SubackPacket;
+
+  handleSuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(4),
+    false,
+    "Should remove from pending",
+  );
+
+  assert.deepStrictEqual(
+    ctx.receivedSubacks.length,
+    1,
+    "Should notify for v5",
+  );
+});

package/client/handlers/handleSuback.ts

@@ -9,11 +9,14 @@ import type { SubackPacket } from "../deps.ts";
  * - Processes SUBACK packets sent by server to confirm SUBSCRIBE requests
  * - Removes the packet ID from pending outgoing messages
  * - Notifies the client about granted QoS levels for each subscription
+ *    - in V5 the reason codes could carry various errors
  */
 export function handleSuback(ctx: Context, packet: SubackPacket): void {
   const id = packet.id;
   ctx.store.pendingOutgoing.delete(id);
   if (packet.protocolLevel !== 5) {
     ctx.receiveSuback(id, packet.returnCodes);
+    return;
   }
+  ctx.receiveSuback(id, packet.reasonCodes);
 }

package/client/handlers/handleUnsuback.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleUnsuback } from "./handleUnsuback.ts";
+import { PacketType } from "../deps.ts";
+import type { UnsubackPacket } from "../deps.ts";
+
+function createMockContext() {
+  const receivedIds: number[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map(),
+    },
+    receiveUnsuback: (id: number) => {
+      receivedIds.push(id);
+      return true;
+    },
+    receivedIds,
+  };
+}
+
+test("handleUnsuback removes from pending and notifies context", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.unsubscribe, id: 1 });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as UnsubackPacket;
+
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(1),
+    false,
+    "Should remove from pending",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [1],
+    "Should notify context of unsuback",
+  );
+});
+
+test("handleUnsuback handles non-existent packet ID gracefully", () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as UnsubackPacket;
+
+  // Should not throw
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [999],
+    "Should still notify context",
+  );
+});
+
+test("handleUnsuback processes multiple UNSUBACKs correctly", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.unsubscribe, id: 1 });
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.unsubscribe, id: 2 });
+  ctx.store.pendingOutgoing.set(3, { type: PacketType.unsubscribe, id: 3 });
+
+  handleUnsuback(ctx as never, {
+    type: PacketType.unsuback,
+    protocolLevel: 4,
+    id: 2,
+  } as UnsubackPacket);
+
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(1), true);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(2), false);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(3), true);
+  assert.deepStrictEqual(ctx.receivedIds, [2]);
+});
+
+test("handleUnsuback works with MQTT v5", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(5, { type: PacketType.unsubscribe, id: 5 });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 5 as const,
+    id: 5,
+    reasonCodes: [0],
+    properties: {},
+  } as UnsubackPacket;
+
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(5), false);
+  assert.deepStrictEqual(ctx.receivedIds, [5]);
+});

package/client/mod.ts

@@ -8,10 +8,21 @@ export {
   DEFAULT_PROTOCOLLEVEL,
   DEFAULT_URL,
 } from "./client.ts";
-export { MQTTLevel } from "./deps.ts";
-export type { ProtocolLevel, QoS } from "./deps.ts";
+export { logger, MQTTLevel, ReasonCode } from "./deps.ts";
+export type {
+  AuthenticationResult,
+  NetAddr,
+  ProtocolLevel,
+  QoS,
+  SockAddr,
+  SockConn,
+  UnixAddr,
+  VsockAddr,
+} from "./deps.ts";
 export type {
   ConnectParameters,
   PublishParameters,
   SubscribeParameters,
 } from "./client.ts";
+
+export type { ConnectionState } from "./ConnectionState.ts";

package/client/store/memoryStore.ts

@@ -5,20 +5,21 @@
 import { assert } from "./deps.ts";
 import type { PacketId } from "./deps.ts";
 
-import {
-  type IStore,
-  maxPacketId,
-  type PacketStore,
-  type PendingAckOutgoing,
-  type pendingIncoming,
-  type PendingOutgoing,
-  type PendingOutgoingPackets,
+import { MAX_PACKET_ID } from "./store.ts";
+
+import type {
+  PacketStore,
+  PendingAckOutgoing,
+  pendingIncoming,
+  PendingOutgoing,
+  PendingOutgoingPackets,
+  Store,
 } from "./store.ts";
 
 /**
- * In-memory implementation of the IStore interface for managing MQTT packet storage
+ * In-memory implementation of the Store interface for managing MQTT packet storage
  */
-export class MemoryStore implements IStore {
+export class MemoryStore implements Store {
   /** Current packet ID counter */
   private packetId: PacketId;
 
@@ -50,7 +51,7 @@ export class MemoryStore implements IStore {
     const currentId = this.packetId;
     do {
       this.packetId++;
-      if (this.packetId > maxPacketId) {
+      if (this.packetId > MAX_PACKET_ID) {
         this.packetId = 1;
       }
     } while (

package/client/store/store.ts

@@ -12,7 +12,7 @@ import type {
 /**
  * Maximum value for MQTT packet IDs (65535)
  */
-export const maxPacketId = 0xffff;
+export const MAX_PACKET_ID = 0xffff;
 
 /**
  * Generic type for storing MQTT packets by their packet ID
@@ -46,7 +46,7 @@ export type PendingOutgoingPackets = PendingAckOutgoing | PendingOutgoing;
 /**
  * Interface defining the storage requirements for MQTT packet state management
  */
-export interface IStore {
+export interface Store {
   /** Store for incoming packets pending processing */
   pendingIncoming: PacketStore<pendingIncoming>;
 
@@ -65,4 +65,6 @@ export interface IStore {
     void,
     unknown
   >;
+  // generate the next packet ID, wrapping around at MAX_PACKET_ID
+  nextId(): PacketId;
 }

package/deno/README.md

@@ -62,5 +62,4 @@ Opifex is also available on [JSR.io](https://jsr.io/@seriousme/opifex).
 # Platform Native
 
 This folder also contains code to run the server using Deno sockets instead of
-NodeJS sockets. You can modify the import statements in the demoServer/client to
-use these instead.
+NodeJS sockets. It also contains an implementation that uses Websockets

package/deno/tcpClient.test.ts

@@ -0,0 +1,75 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getFileData, TcpClient } from "./tcpClient.ts";
+
+// most client testing is already done in tcpServer.test.ts
+
+test("Deno: Test getFileData - valid file, empty file and undefined", async () => {
+  // 1. Test with a valid file containing data
+  const tempFile = await Deno.makeTempFile({
+    prefix: "test_get_file_data_",
+    suffix: ".txt",
+  });
+  const testContent = "Hello MQTT World!";
+
+  try {
+    await Deno.writeTextFile(tempFile, testContent);
+
+    const result = await getFileData(tempFile);
+    assert.strictEqual(
+      result,
+      testContent,
+      "Should return the correct content of the file",
+    );
+
+    // 2. Test with an empty file
+    const emptyTempFile = await Deno.makeTempFile({
+      prefix: "test_empty_",
+      suffix: ".txt",
+    });
+    try {
+      const emptyResult = await getFileData(emptyTempFile);
+      assert.strictEqual(
+        emptyResult,
+        undefined,
+        "Should return undefined if the file is empty",
+      );
+    } finally {
+      // Clean up the empty temporary file
+      await Deno.remove(emptyTempFile);
+    }
+  } finally {
+    // Clean up the valid temporary file even if assertions fail
+    await Deno.remove(tempFile);
+  }
+
+  // 3. Test with undefined filename
+  const undefinedResult = await getFileData(undefined);
+  assert.strictEqual(
+    undefinedResult,
+    undefined,
+    "Should return undefined immediately if filename is undefined",
+  );
+});
+
+test("Test createConn - unsupported protocol", async () => {
+  const client = new TcpClient();
+
+  // Use an unsupported protocol like 'ftp://' to trigger the throw in createConn
+  const invalidParams = {
+    url: new URL("ftp://localhost:1883"),
+    numberOfRetries: 0,
+  };
+
+  // Assert that connect rejects with the specific "Unsupported protocol" error
+  await assert.rejects(
+    async () => {
+      await client.connect(invalidParams);
+    },
+    {
+      name: "Error",
+      message: "Unsupported protocol: ftp:",
+    },
+    "Should throw an error when an unsupported protocol is provided",
+  );
+});

package/deno/tcpClient.ts

@@ -3,16 +3,16 @@
  * it extends the platform agnostic Client class
  * @module
  */
-import { Client } from "../client/client.ts";
-import { logger } from "../client/deps.ts";
-import type { SockConn } from "../client/deps.ts";
+
+import { Client, logger } from "../client/mod.ts";
+import type { SockConn } from "../client/mod.ts";
 
 /**
- * @function getFileData
+ * Fetches data from a file and returns it as a string
+ *
  * @param filename
  * @returns Promise
  *
- * Fetches data from a file and returns it as a string
  * @example
  * const data = await getFileData("data.txt");
  */
@@ -29,12 +29,16 @@ export async function getFileData(
   return data;
 }
 
-/*
- * TCPclient extends the Client class to provide TCP based clients
+/**
+ * TcpClient extends the Client class to provide TCP based clients
  * it is used by the MQTTclient to connect to the broker
  * see mqtt.ts in the /bin folder as an example
  */
 export class TcpClient extends Client {
+  /** Connect using MQTT over TCP
+   * @param hostname the name of the host to connect to
+   * @param port the port number
+   */
   protected async connectMQTT(
     hostname: string,
     port = 1883,
@@ -43,6 +47,15 @@ export class TcpClient extends Client {
     return await Deno.connect({ hostname, port });
   }
 
+  /**
+   * Connect using MQTT over TLS
+   * @param hostname the name of the host to connect to
+   * @param port the port number
+   * @param caCerts the CA certificates to trust
+   * @param cert the clients certificate
+   * @param key the clients private key
+   * @returns a Deno.TlsConn object
+   */
   protected async connectMQTTS(
     hostname: string,
     port = 8883,
@@ -51,19 +64,24 @@ export class TcpClient extends Client {
     key?: string,
   ): Promise<Deno.TlsConn> {
     logger.debug({ hostname, port, caCerts, cert });
-    return await Deno.connectTls({ hostname, port, caCerts, cert, key });
+    const connectOpts = {
+      hostname,
+      port,
+      ...(caCerts !== undefined && { caCerts }),
+      ...(cert !== undefined && { cert }),
+      ...(key !== undefined && { key }),
+    };
+    return await Deno.connectTls(connectOpts);
   }
 
-  protected override createConn(
-    protocol: string,
-    hostname: string,
-    port?: number,
-    caCerts?: string[],
-    cert?: string,
-    key?: string,
-  ): Promise<SockConn> {
-    // if you need to support alternative connection types just
-    // overload this method in your subclass
+  /** createConn is used by the base client class */
+  protected override createConn(): Promise<SockConn> {
+    const { protocol, hostname, port: portStr } = this.connectUrl;
+    const port = Number(portStr);
+    const caCerts = this.caCerts;
+    const cert = this.cert;
+    const key = this.key;
+
     if (protocol === "mqtts:") {
       return this.connectMQTTS(hostname, port, caCerts, cert, key);
     }

package/deno/tcpServer.test.ts

@@ -2,15 +2,12 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { TcpClient } from "./tcpClient.ts";
 import { TcpServer } from "./tcpServer.ts";
-import { logger, LogLevel } from "../utils/mod.ts";
-import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import { delay, logger, LogLevel } from "../utils/mod.ts";
+import type { ProtocolLevel, PublishPacket, QoS } from "../mqttPacket/mod.ts";
 
 logger.level(LogLevel.info);
-export function sleep(ms: number): Promise<unknown> {
-  return new Promise((r) => setTimeout(r, ms));
-}
 
-test("Deno Test pubSub using client and server", async function () {
+test("Deno: Test pubSub using client and server", async () => {
   const server = new TcpServer({ port: 0 }, {});
   server.start();
 
@@ -52,17 +49,17 @@ test("Deno Test pubSub using client and server", async function () {
   });
 
   // the IIFE ensures message reception runs in parallel
-  logger.verbose(`Start receiving`);
+  logger.verbose("Start receiving");
   const received: PublishPacket[] = [];
-  (async function () {
+  (async () => {
     for await (const item of client.messages()) {
-      logger.verbose(`Receiving: ${item.topic} -- ${item.qos}`);
+      logger.verbose("Receiving:", item.topic, "--", item.qos);
       received.push(item);
     }
   })();
   // end of IIFE
   for (const item of publishSet) {
-    logger.verbose(`Publishing: ${item.topic} -- ${item.qos}`);
+    logger.verbose("Publishing:", item.topic, "--", item.qos);
     await client.publish({
       topic: item.topic,
       qos: item.qos,
@@ -70,24 +67,24 @@ test("Deno Test pubSub using client and server", async function () {
     });
   }
 
-  await sleep(100);
-  logger.verbose(`Disconnect client`);
+  await delay(100);
+  logger.verbose("Disconnect client");
   await client.disconnect();
 
-  logger.verbose(`Check completeness`);
+  logger.verbose("Check completeness");
   for (const item of publishSet) {
     const found = received.find((f) =>
       f.topic == item.topic && f.qos === item.qos
     );
-    logger.verbose(`Found: ${item.topic} -- ${item.qos}`);
+    logger.verbose("Found:", item.topic, "--", item.qos);
     assert(found, `${item.topic} -- ${item.qos}`);
   }
 
-  logger.verbose(`Stop server`);
+  logger.verbose("Stop server");
   server.stop();
 });
 
-test("Deno Test subscription persistence after reconnect", async function () {
+test("Deno: Test subscription persistence after reconnect", async () => {
   // Start server
   const server = new TcpServer({ port: 0 }, {});
   server.start();
@@ -95,6 +92,10 @@ test("Deno Test subscription persistence after reconnect", async function () {
   const params = {
     url: new URL(`mqtt://${server.address}:${server.port}`),
     numberOfRetries: 0,
+    options: {
+      protocolLevel: 4 as ProtocolLevel,
+      clean: false,
+    },
   };
 
   const client = new TcpClient();
@@ -111,7 +112,7 @@ test("Deno Test subscription persistence after reconnect", async function () {
   });
 
   // Start receiving messages
-  (async function () {
+  (async () => {
     for await (const item of client.messages()) {
       received.push(item);
     }
@@ -119,11 +120,11 @@ test("Deno Test subscription persistence after reconnect", async function () {
 
   // Disconnect client
   await client.disconnect();
-  await sleep(100);
+  await delay(100);
 
   // Reconnect client
   await client.connect(params);
-  await sleep(100);
+  await delay(100);
 
   // Publish test message
   await client.publish({
@@ -132,8 +133,8 @@ test("Deno Test subscription persistence after reconnect", async function () {
     payload: new Uint8Array([0x01]),
   });
 
-  await sleep(100);
-  logger.verbose(`Disconnect client`);
+  await delay(100);
+  logger.verbose("Disconnect client");
   await client.disconnect();
 
   // Verify message was received

package/deno/tcpServer.ts

@@ -7,12 +7,16 @@
 import { MqttServer } from "../server/mod.ts";
 import type { MqttServerOptions } from "../server/mod.ts";
 
-/*
- * TCP server that wraps a MqttServer, see demoServer.ts in the /bin folder
+/**
+ * TCP server that wraps a MqttServer, see the /examples folder
  */
 export class TcpServer {
   private listener: Deno.Listener<Deno.Conn>;
   private mqttServer: MqttServer;
+
+  /**
+   * Create a new TCP server
+   */
   constructor(
     serverOptions: Deno.TcpListenOptions,
     mqttOptions: MqttServerOptions,
@@ -21,26 +25,44 @@ export class TcpServer {
     this.mqttServer = new MqttServer(mqttOptions);
   }
 
-  async start() {
+  /**
+   * Start listening
+   */
+  async start(): Promise<void> {
     for await (const conn of this.listener) {
       this.mqttServer.serve(conn);
     }
   }
-  stop() {
+
+  /**
+   * Stop listening
+   */
+  stop(): void {
+    this.mqttServer.close(true);
     this.listener.close();
   }
 
+  /**
+   * The port number the server is listening on
+   */
   get port(): number | undefined {
+    // deno-coverage-ignore-start
     if (this.listener.addr.transport === "tcp") {
       return this.listener.addr.port;
     }
     return undefined;
+    // deno-coverage-ignore-stop
   }
 
+  /**
+   * The address the server is listening on
+   */
   get address(): string | undefined {
+    // deno-coverage-ignore-start
     if (this.listener.addr.transport === "tcp") {
       return this.listener.addr.hostname;
     }
     return undefined;
+    // deno-coverage-ignore-stop
   }
 }