@seriousme/opifex 1.11.3 → 2.1.0

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);

package/client/handlers/handlePublish.test.ts

@@ -0,0 +1,188 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePublish } from "./handlePublish.ts";
+import { PacketType } from "../deps.ts";
+import type { PublishPacket } from "../deps.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  const receivedPublishes: PublishPacket[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map(),
+      pendingIncoming: new Map<number, PublishPacket>(),
+      pendingAckOutgoing: new Map(),
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    receivePublish: (packet: PublishPacket) => {
+      receivedPublishes.push(packet);
+    },
+    sentPackets,
+    receivedPublishes,
+  };
+}
+
+test("handlePublish QoS 0 delivers message without acknowledgment", async () => {
+  const ctx = createMockContext();
+  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 PublishPacket;
+
+  await handlePublish(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    1,
+    "Should receive publish",
+  );
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    0,
+    "QoS 0 should not send acknowledgment",
+  );
+});
+
+test("handlePublish QoS 1 delivers message and sends PUBACK", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 1 as const,
+    retain: false,
+    dup: false,
+    id: 1,
+  } as PublishPacket;
+
+  await handlePublish(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    1,
+    "Should receive publish",
+  );
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    1,
+    "Should send PUBACK",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.puback,
+    "Should send PUBACK packet",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { id: number }).id,
+    1,
+    "PUBACK should have same packet ID",
+  );
+});
+
+test("handlePublish QoS 2 stores message and sends PUBREC", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 2 as const,
+    retain: false,
+    dup: false,
+    id: 2,
+  } as PublishPacket;
+
+  await handlePublish(ctx as never, packet);
+
+  // QoS 2: should NOT deliver message yet (waits for PUBREL)
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    0,
+    "QoS 2 should not deliver message until PUBREL",
+  );
+
+  // Should store the packet
+  assert.deepStrictEqual(
+    ctx.store.pendingIncoming.has(2),
+    true,
+    "Should store incoming packet",
+  );
+
+  // Should send PUBREC
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    1,
+    "Should send PUBREC",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubrec,
+    "Should send PUBREC packet",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { id: number }).id,
+    2,
+    "PUBREC should have same packet ID",
+  );
+});
+
+test("handlePublish without packet ID for QoS 1 does nothing", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 1 as const,
+    retain: false,
+    dup: false,
+    // No id
+  } as PublishPacket;
+
+  await handlePublish(ctx as never, packet);
+
+  // Without packet ID, QoS 1/2 handling is skipped
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    0,
+    "Should not receive without packet ID",
+  );
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    0,
+    "Should not send without packet ID",
+  );
+});
+
+test("handlePublish QoS 2 without store does nothing", async () => {
+  const ctx = createMockContext();
+  (ctx as unknown as { store: null }).store = null as never;
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 2 as const,
+    retain: false,
+    dup: false,
+    id: 3,
+  } as PublishPacket;
+
+  // Should not throw, just silently skip
+  await handlePublish(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    0,
+    "Should not send without store",
+  );
+});

package/client/handlers/handlePubrec.test.ts

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePubrec } from "./handlePubrec.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { PubrecPacket } from "../deps.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map<number, unknown>(),
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    sentPackets,
+  };
+}
+
+test("handlePubrec sends PUBREL for pending outgoing QoS 2", async () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.publish, id: 1 });
+
+  const packet = {
+    type: PacketType.pubrec,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as PubrecPacket;
+
+  await handlePubrec(ctx as never, packet);
+
+  // Should send PUBREL
+  assert.deepStrictEqual(ctx.sentPackets.length, 1, "Should send PUBREL");
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubrel,
+    "Should send PUBREL packet",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { id: number }).id,
+    1,
+    "PUBREL should have same packet ID",
+  );
+
+  // Should move from pendingOutgoing to pendingAckOutgoing
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(1),
+    false,
+    "Should remove from pendingOutgoing",
+  );
+  assert.deepStrictEqual(
+    ctx.store.pendingAckOutgoing.has(1),
+    true,
+    "Should add to pendingAckOutgoing",
+  );
+});
+
+test("handlePubrec ignores unknown packet ID", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.pubrec,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as PubrecPacket;
+
+  await handlePubrec(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    0,
+    "Should not send PUBREL for unknown ID",
+  );
+  assert.deepStrictEqual(
+    ctx.store.pendingAckOutgoing.has(999),
+    false,
+    "Should not add to pendingAckOutgoing",
+  );
+});
+
+test("handlePubrec stores PUBREL packet for retransmission", async () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(5, { type: PacketType.publish, id: 5 });
+
+  const packet = {
+    type: PacketType.pubrec,
+    protocolLevel: 4 as const,
+    id: 5,
+  } as PubrecPacket;
+
+  await handlePubrec(ctx as never, packet);
+
+  const storedPubrel = ctx.store.pendingAckOutgoing.get(5);
+  assert.ok(storedPubrel, "Should store PUBREL");
+  assert.deepStrictEqual(
+    (storedPubrel as { type: number }).type,
+    PacketType.pubrel,
+    "Stored packet should be PUBREL",
+  );
+});
+
+test("handlePuback processes V5 publish rejection", () => {
+  const ctx = createMockContext();
+  const reasonCode = ReasonCode.notAuthorized;
+  ctx.store.pendingOutgoing.set(2, {
+    type: PacketType.publish,
+    topic: "Test Pubrec",
+  });
+  assert.rejects(() =>
+    handlePubrec(ctx as never, {
+      type: PacketType.pubrec,
+      protocolLevel: 5,
+      id: 2,
+      reasonCode,
+    } as PubrecPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handlePubrec.ts

@@ -1,5 +1,5 @@
 import type { Context } from "../context.ts";
-import { PacketType } from "../deps.ts";
+import { PacketType, ReasonCodeByNumber } from "../deps.ts";
 import type { PubrecPacket, PubrelPacket } from "../deps.ts";
 
 /**
@@ -26,6 +26,10 @@ export async function handlePubrec(
     id,
   };
   if (ctx.store.pendingOutgoing.has(id)) {
+    if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+      ctx.store.pendingOutgoing.delete(id);
+      throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+    }
     ctx.store.pendingAckOutgoing.set(id, ack);
     ctx.store.pendingOutgoing.delete(id);
     await ctx.send(ack);

package/client/handlers/handlePubrel.test.ts

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePubrel } from "./handlePubrel.ts";
+import { PacketType } from "../deps.ts";
+import type { PublishPacket, PubrelPacket } from "../deps.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  const receivedPublishes: PublishPacket[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map(),
+      pendingIncoming: new Map<number, PublishPacket>(),
+      pendingAckOutgoing: new Map(),
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    receivePublish: (packet: PublishPacket) => {
+      receivedPublishes.push(packet);
+    },
+    sentPackets,
+    receivedPublishes,
+  };
+}
+
+test("handlePubrel delivers stored message and sends PUBCOMP", async () => {
+  const ctx = createMockContext();
+  const storedPublish = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 2 as const,
+    retain: false,
+    dup: false,
+    id: 1,
+  } as PublishPacket;
+  ctx.store.pendingIncoming.set(1, storedPublish);
+
+  const packet = {
+    type: PacketType.pubrel,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as PubrelPacket;
+
+  await handlePubrel(ctx as never, packet);
+
+  // Should deliver the message
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    1,
+    "Should deliver stored message",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedPublishes[0].topic,
+    "test/topic",
+    "Should deliver correct message",
+  );
+
+  // Should send PUBCOMP
+  assert.deepStrictEqual(ctx.sentPackets.length, 1, "Should send PUBCOMP");
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubcomp,
+    "Should send PUBCOMP packet",
+  );
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { id: number }).id,
+    1,
+    "PUBCOMP should have same packet ID",
+  );
+
+  // Should remove from pending incoming
+  assert.deepStrictEqual(
+    ctx.store.pendingIncoming.has(1),
+    false,
+    "Should remove from pendingIncoming",
+  );
+});
+
+test("handlePubrel ignores unknown packet ID", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.pubrel,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as PubrelPacket;
+
+  await handlePubrel(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    0,
+    "Should not deliver for unknown ID",
+  );
+  assert.deepStrictEqual(
+    ctx.sentPackets.length,
+    0,
+    "Should not send PUBCOMP for unknown ID",
+  );
+});
+
+test("handlePubrel completes QoS 2 flow correctly", async () => {
+  const ctx = createMockContext();
+
+  // Simulate full QoS 2 flow - message already stored from PUBLISH
+  const storedPublish = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "sensors/temp",
+    payload: new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]), // "Hello"
+    qos: 2 as const,
+    retain: false,
+    dup: false,
+    id: 42,
+  } as PublishPacket;
+  ctx.store.pendingIncoming.set(42, storedPublish);
+
+  await handlePubrel(ctx as never, {
+    type: PacketType.pubrel,
+    protocolLevel: 4,
+    id: 42,
+  } as PubrelPacket);
+
+  // Verify complete flow
+  assert.deepStrictEqual(ctx.receivedPublishes.length, 1);
+  assert.deepStrictEqual(ctx.receivedPublishes[0], storedPublish);
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubcomp,
+  );
+  assert.deepStrictEqual(ctx.store.pendingIncoming.size, 0);
+});