@seriousme/opifex 1.11.3 → 2.1.0

package/server/handlers/handlePubcomp.test.ts

@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import type { AnyPacket } from "../deps.ts";
+import { MQTTLevel, PacketType } from "../deps.ts";
+import {
+  connect,
+  disconnect,
+  ping,
+  startMockServer,
+} from "../../dev_utils/mod.ts";
+
+test("PUBCOMP is handled without error", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Send PUBCOMP (simulating final step of QoS 2 outgoing flow)
+  const pubcompPacket: AnyPacket = {
+    type: PacketType.pubcomp,
+    protocolLevel: MQTTLevel.v4,
+    id: 9999,
+  };
+  mqttConn.send(pubcompPacket);
+
+  // Verify server is still responsive
+  await ping(mqttConn);
+
+  await disconnect(mqttConn);
+});

package/server/handlers/handlePubcomp.ts

@@ -9,9 +9,10 @@ import type { PubcompPacket } from "../deps.ts";
  * This is the fourth and final packet of the QoS 2 protocol exchange.
  * When received, it removes the message from the pendingAckOutgoing store.
  */
-export function handlePubcomp(ctx: Context, packet: PubcompPacket): void {
+export async function handlePubcomp(
+  ctx: Context,
+  packet: PubcompPacket,
+): Promise<void> {
   const id = packet.id;
-  if (ctx.store?.pendingAckOutgoing.has(id)) {
-    ctx.store.pendingAckOutgoing.delete(id);
-  }
+  await ctx.persistence.deletePendingAck(ctx.clientId!, id);
 }

package/server/handlers/handlePublish.test.ts

@@ -0,0 +1,471 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  connect,
+  connect5,
+  disconnect,
+  disconnect5,
+  isAuthenticatedBroker,
+  ping,
+  publish,
+  publish5,
+  startMockServer,
+} from "../../dev_utils/mod.ts";
+
+import { PacketType, ReasonCode } from "../deps.ts";
+
+test("PUBLISH QoS 0 does not receive acknowledgment", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Publish QoS 0
+  await publish(mqttConn, "hello", 0);
+
+  // Send PINGREQ to verify no PUBACK was queued before it
+  // QoS 0 should not produce PUBACK, next response should be PINGRES
+  await ping(mqttConn);
+
+  await disconnect(mqttConn);
+});
+
+test("PUBLISH QoS 1 receives PUBACK", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Publish QoS 1
+  await publish(mqttConn, "test/topic", 1);
+
+  await disconnect(mqttConn);
+});
+
+test("PUBLISH QoS 2 receives PUBREC", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Publish QoS 2
+  await publish(mqttConn, "test/topic", 2, { id: 2, payload: "hello" });
+  await disconnect(mqttConn);
+});
+
+test("Publish with missing isAuthorizedToPublish handler authorizes publish", async () => {
+  const { mqttConn, mqttServer } = startMockServer();
+  mqttServer.handlers.isAuthorizedToPublish = undefined;
+
+  await connect(mqttConn);
+  // Try to publish to unauthorized topic
+  await publish(mqttConn, "topic/unauthorized", 1, { id: 3, payload: "test" });
+
+  await disconnect(mqttConn);
+});
+
+test("Publish with isAuthorizedToPublish handler throwing error rejects publish", async () => {
+  const { mqttConn, mqttServer } = startMockServer();
+  mqttServer.handlers.isAuthorizedToPublish = () => {
+    throw Error("kaboom");
+  };
+
+  await connect(mqttConn);
+  await publish(mqttConn, "topic/kaboom", 1, {
+    id: 3,
+    payload: "test",
+    checkAcks: false,
+  });
+  await mqttConn.next();
+  assert.equal(mqttConn.isClosed, true, "expect connection to be closed");
+});
+
+test("PUBLISH to unauthorized topic is rejected", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Try to publish to unauthorized topic
+  await publish(mqttConn, "topic/unauthorized", 1, {
+    id: 3,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  await mqttConn.next();
+  assert.equal(mqttConn.isClosed, true, "expect connection to be closed");
+});
+
+test("PUBLISH to $SYS topic is rejected", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Try to publish to $SYS topic
+  await publish(mqttConn, "$SYS/broker/clients", 1, {
+    id: 3,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  await mqttConn.next();
+  assert.equal(mqttConn.isClosed, true, "expect connection to be closed");
+});
+
+test("PUBLISH to $SYS topic is allowed for brokers", async () => {
+  const { mqttConn, mqttServer } = startMockServer();
+  // this will set the context.isBroker=true on authentication
+  mqttServer.handlers.isAuthenticated = isAuthenticatedBroker;
+
+  await connect(mqttConn, { clientId: "broker1" });
+  // Try to publish to $SYS topic
+  await publish(mqttConn, "$SYS/broker/clients", 0, {
+    id: 3,
+    payload: "test",
+  });
+  // connection should still be alive
+  await ping(mqttConn);
+  await disconnect(mqttConn);
+});
+
+// ============================================================================
+// Retain Not Supported Tests
+// ============================================================================
+
+test("PUBLISH with retain when retainAvailable is false closes connection in v4", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { retainAvailable: false } },
+  });
+
+  await connect(mqttConn);
+
+  // Send publish with retain flag enabled
+  await publish(mqttConn, "test/topic", 1, {
+    id: 1,
+    payload: "test",
+    retain: true,
+    checkAcks: false,
+  });
+
+  // Protocol level 4 should close the connection on retain error
+  await mqttConn.next();
+  assert.equal(mqttConn.isClosed, true, "expect connection to be closed in v4");
+});
+
+test("PUBLISH v5 with retain when retainAvailable is false receives PUBACK with retainNotSupported (QoS 1)", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { retainAvailable: false } },
+  });
+
+  await connect5(mqttConn);
+
+  // Send publish with retain flag enabled
+  await publish5(mqttConn, "test/topic", 1, {
+    id: 1,
+    payload: "test",
+    retain: true,
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback, "Expected PUBACK packet");
+  assert.equal(pubAck.id, 1);
+  assert.equal(
+    pubAck.reasonCode,
+    ReasonCode.unspecifiedError,
+    "Expected retainNotSupported (0x9A) reasonCode in v5",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 with retain when retainAvailable is false receives PUBREC with retainNotSupported (QoS 2)", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { retainAvailable: false } },
+  });
+
+  await connect5(mqttConn);
+
+  // Send publish with retain flag enabled
+  await publish5(mqttConn, "test/topic", 2, {
+    id: 2,
+    payload: "test",
+    retain: true,
+    checkAcks: false,
+  });
+
+  const { value: pubRec } = await mqttConn.next();
+  assert.equal(pubRec.type, PacketType.pubrec, "Expected PUBREC packet");
+  assert.equal(pubRec.id, 2);
+  assert.equal(
+    pubRec.reasonCode,
+    ReasonCode.unspecifiedError,
+    "Expected retainNotSupported (0x9A) reasonCode in v5",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+// ============================================================================
+// MQTT v5 Specific Authorization Tests
+// ============================================================================
+
+test("PUBLISH v5 QoS 0 to unauthorized topic is silently dropped", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  // QoS 0 gets no error response message according to v5 spec
+  await publish5(mqttConn, "topic/unauthorized", 0, {
+    payload: "test",
+    checkAcks: false,
+  });
+
+  // Verify connection is still open by executing a successful PING
+  await ping(mqttConn);
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 QoS 1 to unauthorized topic receives PUBACK with notAuthorized", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "topic/unauthorized", 1, {
+    id: 10,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback, "Expected PUBACK");
+  assert.equal(pubAck.id, 10);
+  assert.equal(
+    pubAck.reasonCode,
+    ReasonCode.notAuthorized,
+    "Expected notAuthorized (0x87) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 QoS 2 to unauthorized topic receives PUBREC with notAuthorized", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "topic/unauthorized", 2, {
+    id: 11,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubRec } = await mqttConn.next();
+  assert.equal(pubRec.type, PacketType.pubrec, "Expected PUBREC");
+  assert.equal(pubRec.id, 11);
+  assert.equal(
+    pubRec.reasonCode,
+    ReasonCode.notAuthorized,
+    "Expected notAuthorized (0x87) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 includes reasonString when provideReasonStrings is enabled", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { provideReasonStrings: true } },
+  });
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "topic/unauthorized", 1, {
+    id: 12,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback);
+  assert.equal(pubAck.reasonCode, ReasonCode.notAuthorized);
+  assert.equal(
+    pubAck.properties?.reasonString,
+    "Client not authorized to publish to topic/unauthorized",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+// ============================================================================
+// Invalid Topic & Topic Alias Tests
+// ============================================================================
+
+test("PUBLISH v4 with invalid topic containing wildcards closes connection", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  await publish(mqttConn, "invalid/+/topic", 1, {
+    id: 1,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  await mqttConn.next();
+  assert.equal(mqttConn.isClosed, true, "expect connection to be closed in v4");
+});
+
+test("PUBLISH v5 QoS 1 with invalid topic containing wildcards receives PUBACK with topicNameInvalid", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "invalid/+/topic", 1, {
+    id: 1,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback);
+  assert.equal(pubAck.id, 1);
+  assert.equal(
+    pubAck.reasonCode,
+    ReasonCode.topicNameInvalid,
+    "Expected topicNameInvalid (0x90) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 QoS 2 with invalid topic containing wildcards receives PUBREC with topicNameInvalid", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "invalid/#", 2, {
+    id: 2,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubRec } = await mqttConn.next();
+  assert.equal(pubRec.type, PacketType.pubrec);
+  assert.equal(pubRec.id, 2);
+  assert.equal(
+    pubRec.reasonCode,
+    ReasonCode.topicNameInvalid,
+    "Expected topicNameInvalid (0x90) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 with topic level count exceeding maxTopicLevels receives topicNameInvalid", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { maxTopicLevels: 1 } },
+  });
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "level1/level2", 1, {
+    id: 3,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback);
+  assert.equal(
+    pubAck.reasonCode,
+    ReasonCode.topicNameInvalid,
+    "Expected topicNameInvalid (0x90) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 with empty topic and no topic alias receives topicNameInvalid", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "", 1, {
+    id: 4,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback);
+  assert.equal(
+    pubAck.reasonCode,
+    ReasonCode.topicNameInvalid,
+    "Expected topicNameInvalid (0x90) reasonCode",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 with topic alias works", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+  // Topic with topicAlias
+  await publish5(mqttConn, "topic/alias", 1, {
+    id: 4,
+    payload: "test",
+    properties: { topicAlias: 1 },
+  });
+  // Empty topic with topicAlias
+  await publish5(mqttConn, "", 1, {
+    id: 5,
+    payload: "test",
+    properties: { topicAlias: 1 },
+  });
+
+  await disconnect5(mqttConn);
+});
+
+test("PUBLISH v5 with invalid topic alias results in disconnect", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+  // Empty topic with unknown topicAlias
+  await publish5(mqttConn, "", 1, {
+    id: 5,
+    payload: "test",
+    properties: { topicAlias: 1 },
+    checkAcks: false,
+  });
+  const { value: disc } = await mqttConn.next();
+  assert.equal(disc.type, PacketType.disconnect);
+  assert.equal(
+    disc.reasonCode,
+    ReasonCode.topicAliasInvalid,
+    "Expected topicAliasInvalid (0x94) reasonCode",
+  );
+});
+
+test("PUBLISH v5 omits reasonString when provideReasonStrings is false", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { provideReasonStrings: false } },
+  });
+
+  await connect5(mqttConn);
+
+  await publish5(mqttConn, "topic/unauthorized", 1, {
+    id: 6,
+    payload: "test",
+    checkAcks: false,
+  });
+
+  const { value: pubAck } = await mqttConn.next();
+  assert.equal(pubAck.type, PacketType.puback);
+  assert.equal(pubAck.reasonCode, ReasonCode.notAuthorized);
+  assert.equal(
+    pubAck.properties?.reasonString,
+    undefined,
+    "Expected reasonString to be omitted when provideReasonStrings is false",
+  );
+
+  await disconnect5(mqttConn);
+});