@seriousme/opifex 1.11.3 → 2.0.3

package/client/handlers/handleDisconnect.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleDisconnect } from "./handleDisconnect.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { DisconnectPacket } from "../deps.ts";
+
+function createMockContext() {
+  return {
+    close: () => {},
+  };
+}
+
+test("handleDisconnect processes V5 rejection", () => {
+  const ctx = createMockContext();
+  const reasonCode = ReasonCode.notAuthorized;
+  assert.throws(() =>
+    handleDisconnect(ctx as never, {
+      type: PacketType.disconnect,
+      protocolLevel: 5,
+      reasonCode,
+    } as DisconnectPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handleDisconnect.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../context.ts";
+import type { DisconnectPacket } from "../deps.ts";
+import { ReasonCodeByNumber } from "../deps.ts";
+
+/**
+ * Handles Disconnect Packet sent by the broker (V5 only)
+ * @param ctx - The MQTT client context
+ * @param packet - The PUBACK packet received from the broker
+ * @description
+ * - throw error
+ */
+export function handleDisconnect(ctx: Context, packet: DisconnectPacket): void {
+  if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+    throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+  }
+  ctx.close();
+}

package/client/handlers/handlePacket.test.ts

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePacket } from "./handlePacket.ts";
+import { ConnectionState } from "../ConnectionState.ts";
+import { AuthenticationResult, MQTTLevel, PacketType } from "../deps.ts";
+import type { AnyPacket, PublishPacket } from "../deps.ts";
+import { Deferred } from "../../utils/mod.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  const receivedPublishes: PublishPacket[] = [];
+  const receivedIds: {
+    puback: number[];
+    pubcomp: number[];
+    suback: number[];
+    unsuback: number[];
+  } = {
+    puback: [],
+    pubcomp: [],
+    suback: [],
+    unsuback: [],
+  };
+  return {
+    connectionState: ConnectionState.connecting as string,
+    protocolLevel: 4 as const,
+    mqttConn: { codecOpts: { protocolLevel: MQTTLevel.unknown } },
+    pingTimer: { reset: () => {}, clear: () => {} },
+    unresolvedConnect: new Deferred<number>(),
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map<number, PublishPacket>(),
+      pendingAckOutgoing: new Map<number, unknown>(),
+      async *pendingOutgoingPackets() {},
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    receivePublish: (packet: PublishPacket) => {
+      receivedPublishes.push(packet);
+    },
+    receivePuback: (id: number) => {
+      receivedIds.puback.push(id);
+      return true;
+    },
+    receivePubcomp: (id: number) => {
+      receivedIds.pubcomp.push(id);
+      return true;
+    },
+    receiveSuback: (id: number, _codes: number[]) => {
+      receivedIds.suback.push(id);
+      return true;
+    },
+    receiveUnsuback: (id: number) => {
+      receivedIds.unsuback.push(id);
+      return true;
+    },
+    sentPackets,
+    receivedPublishes,
+    receivedIds,
+  };
+}
+
+test("handlePacket dispatches CONNACK before connected", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.connack,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.ok,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.connected,
+    "Should handle CONNACK and set connected state",
+  );
+});
+
+test("handlePacket rejects non-CONNACK before connected", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.pingreq,
+    protocolLevel: 4,
+  } as AnyPacket;
+
+  await assert.rejects(
+    handlePacket(ctx as never, packet),
+    /while connecting/,
+    "Should reject packets before CONNACK",
+  );
+});
+
+test("handlePacket dispatches PUBLISH after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 0 as const,
+    retain: false,
+    dup: false,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    1,
+    "Should dispatch PUBLISH to handler",
+  );
+});
+
+test("handlePacket dispatches PUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.puback,
+    [1],
+    "Should dispatch PUBACK to handler",
+  );
+});
+
+test("handlePacket dispatches PINGRES silently", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.pingres,
+    protocolLevel: 4,
+  } as AnyPacket;
+
+  // Should not throw
+  await handlePacket(ctx as never, packet);
+
+  // PINGRES is silently handled (no specific action)
+  assert.deepStrictEqual(ctx.sentPackets.length, 0);
+});
+
+test("handlePacket dispatches SUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.subscribe });
+
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 4 as const,
+    id: 1,
+    returnCodes: [0],
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.suback,
+    [1],
+    "Should dispatch SUBACK to handler",
+  );
+});
+
+test("handlePacket dispatches UNSUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.unsubscribe });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 2,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.unsuback,
+    [2],
+    "Should dispatch UNSUBACK to handler",
+  );
+});
+
+test("handlePacket rejects unexpected packet types", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  // CONNECT shouldn't be received by client after connection
+  const packet = {
+    type: PacketType.connect,
+    protocolName: "MQTT",
+    protocolLevel: 4 as const,
+    clientId: "test",
+    clean: true,
+    keepAlive: 0,
+  } as AnyPacket;
+
+  await assert.rejects(
+    handlePacket(ctx as never, packet),
+    /unexpected/i,
+    "Should reject unexpected packet types",
+  );
+});
+
+test("handlePacket handles QoS 2 flow packets", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  // Test PUBREC
+  ctx.store.pendingOutgoing.set(10, { type: PacketType.publish, id: 10 });
+  await handlePacket(ctx as never, {
+    type: PacketType.pubrec,
+    protocolLevel: 4,
+    id: 10,
+  } as AnyPacket);
+  assert.deepStrictEqual(ctx.sentPackets.length, 1);
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubrel,
+  );
+
+  // Test PUBCOMP
+  ctx.store.pendingAckOutgoing.set(10, { type: PacketType.pubrel, id: 10 });
+  await handlePacket(ctx as never, {
+    type: PacketType.pubcomp,
+    protocolLevel: 4,
+    id: 10,
+  } as AnyPacket);
+  assert.deepStrictEqual(ctx.receivedIds.pubcomp, [10]);
+});

package/client/handlers/handlePacket.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { ConnectionState } from "../ConnectionState.ts";
+import { handleAuth } from "./handleAuth.ts";
 import { handleConnack } from "./handleConnack.ts";
 import { handlePublish } from "./handlePublish.ts";
 import { handlePuback } from "./handlePuback.ts";
@@ -8,10 +9,13 @@ import { handlePubrel } from "./handlePubrel.ts";
 import { handlePubcomp } from "./handlePubcomp.ts";
 import { handleSuback } from "./handleSuback.ts";
 import { handleUnsuback } from "./handleUnsuback.ts";
+import { handleDisconnect } from "./handleDisconnect.ts";
 import { logger, PacketNameByType, PacketType } from "../deps.ts";
 import type {
   AnyPacket,
+  AuthPacket,
   ConnackPacket,
+  DisconnectPacket,
   PubackPacket,
   PubcompPacket,
   PublishPacket,
@@ -35,14 +39,21 @@ export async function handlePacket(
   logger.debug({ received: PacketNameByType[packet.type], packet });
   if (ctx.connectionState !== ConnectionState.connected) {
     if (packet.type === PacketType.connack) {
-      handleConnack(packet as ConnackPacket, ctx);
-    } else {
-      throw new Error(
-        `Received ${PacketNameByType[packet.type]} packet before connect`,
-      );
+      handleConnack(ctx, packet as ConnackPacket);
+      return;
     }
+    if (packet.type === PacketType.auth) {
+      await handleAuth(ctx, packet as AuthPacket);
+      return;
+    }
+    throw new Error(
+      `Received ${PacketNameByType[packet.type]} packet while connecting`,
+    );
   } else {
     switch (packet.type) {
+      case PacketType.auth:
+        await handleAuth(ctx, packet as AuthPacket);
+        break;
       case PacketType.pingres:
         break;
       case PacketType.publish:
@@ -66,6 +77,9 @@ export async function handlePacket(
       case PacketType.unsuback:
         handleUnsuback(ctx, packet as UnsubackPacket);
         break;
+      case PacketType.disconnect:
+        handleDisconnect(ctx, packet as DisconnectPacket);
+        break;
 
       default:
         throw new Error(

package/client/handlers/handlePuback.test.ts

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePuback } from "./handlePuback.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { PubackPacket } 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(),
+    },
+    receivePuback: (id: number) => {
+      receivedIds.push(id);
+      return true;
+    },
+    receivedIds,
+  };
+}
+
+test("handlePuback removes packet from pending and notifies context", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.publish });
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as PubackPacket;
+
+  handlePuback(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 puback",
+  );
+});
+
+test("handlePuback handles non-existent packet ID gracefully", () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as PubackPacket;
+
+  // Should not throw
+  handlePuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [999],
+    "Should still notify context",
+  );
+});
+
+test("handlePuback processes multiple PUBACKs correctly", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.publish });
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.publish });
+  ctx.store.pendingOutgoing.set(3, { type: PacketType.publish });
+
+  handlePuback(ctx as never, {
+    type: PacketType.puback,
+    protocolLevel: 4,
+    id: 2,
+  } as PubackPacket);
+
+  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("handlePuback processes V5 publish rejection", () => {
+  const ctx = createMockContext();
+  const reasonCode = ReasonCode.notAuthorized;
+  ctx.store.pendingOutgoing.set(2, {
+    type: PacketType.publish,
+    topic: "Test Puback",
+  });
+  assert.throws(() =>
+    handlePuback(ctx as never, {
+      type: PacketType.puback,
+      protocolLevel: 5,
+      id: 2,
+      reasonCode,
+    } as PubackPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handlePuback.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import type { PubackPacket } from "../deps.ts";
+import { ReasonCodeByNumber } from "../deps.ts";
 
 /**
  * Handles PUBACK packet processing for QoS level 1 PUBLISH responses
@@ -12,5 +13,10 @@ import type { PubackPacket } from "../deps.ts";
 export function handlePuback(ctx: Context, packet: PubackPacket): void {
   const id = packet.id;
   ctx.store.pendingOutgoing.delete(id);
+
+  if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+    ctx.store.pendingOutgoing.delete(id);
+    throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+  }
   ctx.receivePuback(id);
 }

package/client/handlers/handlePubcomp.test.ts

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePubcomp } from "./handlePubcomp.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { PubcompPacket } from "../deps.ts";
+
+function createMockContext() {
+  const receivedIds: number[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map<number, unknown>(),
+    },
+    receivePubcomp: (id: number) => {
+      receivedIds.push(id);
+      return true;
+    },
+    receivedIds,
+  };
+}
+
+test("handlePubcomp removes from pendingAckOutgoing and notifies", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingAckOutgoing.set(1, { type: PacketType.pubrel, id: 1 });
+
+  const packet = {
+    type: PacketType.pubcomp,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as PubcompPacket;
+
+  handlePubcomp(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingAckOutgoing.has(1),
+    false,
+    "Should remove from pendingAckOutgoing",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [1],
+    "Should notify context of pubcomp",
+  );
+});
+
+test("handlePubcomp ignores unknown packet ID", () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.pubcomp,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as PubcompPacket;
+
+  handlePubcomp(ctx as never, packet);
+
+  // Should not notify for unknown ID (based on implementation)
+  assert.deepStrictEqual(
+    ctx.receivedIds.length,
+    0,
+    "Should not notify for unknown ID",
+  );
+});
+
+test("handlePubcomp completes QoS 2 outgoing flow", () => {
+  const ctx = createMockContext();
+
+  // Simulate QoS 2 state after PUBREC was received
+  ctx.store.pendingAckOutgoing.set(5, { type: PacketType.pubrel, id: 5 });
+
+  handlePubcomp(ctx as never, {
+    type: PacketType.pubcomp,
+    protocolLevel: 4,
+    id: 5,
+  } as PubcompPacket);
+
+  assert.deepStrictEqual(ctx.store.pendingAckOutgoing.size, 0);
+  assert.deepStrictEqual(ctx.receivedIds, [5]);
+});
+
+test("handlePubcomp processes multiple PUBCOMPs correctly", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingAckOutgoing.set(1, { type: PacketType.pubrel, id: 1 });
+  ctx.store.pendingAckOutgoing.set(2, { type: PacketType.pubrel, id: 2 });
+  ctx.store.pendingAckOutgoing.set(3, { type: PacketType.pubrel, id: 3 });
+
+  handlePubcomp(ctx as never, {
+    type: PacketType.pubcomp,
+    protocolLevel: 4,
+    id: 2,
+  } as PubcompPacket);
+
+  assert.deepStrictEqual(ctx.store.pendingAckOutgoing.has(1), true);
+  assert.deepStrictEqual(ctx.store.pendingAckOutgoing.has(2), false);
+  assert.deepStrictEqual(ctx.store.pendingAckOutgoing.has(3), true);
+  assert.deepStrictEqual(ctx.receivedIds, [2]);
+});
+
+test("handlePubComp processes V5 rejection", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingAckOutgoing.set(3, { type: PacketType.pubrel, id: 3 });
+  const reasonCode = ReasonCode.notAuthorized;
+  assert.throws(() =>
+    handlePubcomp(ctx as never, {
+      type: PacketType.pubcomp,
+      protocolLevel: 5,
+      id: 3,
+      reasonCode,
+    } as PubcompPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handlePubcomp.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import type { PubcompPacket } from "../deps.ts";
+import { ReasonCodeByNumber } from "../deps.ts";
 
 /**
  * Handles PUBCOMP packets which are the response to PUBREL packets in QoS 2 flow
@@ -12,6 +13,10 @@ import type { PubcompPacket } from "../deps.ts";
  */
 export function handlePubcomp(ctx: Context, packet: PubcompPacket): void {
   const id = packet.id;
+  if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+    ctx.store.pendingOutgoing.delete(id);
+    throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+  }
   if (ctx.store.pendingAckOutgoing.has(id)) {
     ctx.store.pendingAckOutgoing.delete(id);
     ctx.receivePubcomp(id);