@seriousme/opifex 1.11.3 → 2.0.3

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

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,7 +8,7 @@ export {
   DEFAULT_PROTOCOLLEVEL,
   DEFAULT_URL,
 } from "./client.ts";
-export { MQTTLevel } from "./deps.ts";
+export { MQTTLevel, ReasonCode } from "./deps.ts";
 export type { ProtocolLevel, QoS } from "./deps.ts";
 export type {
   ConnectParameters,