@seriousme/opifex 1.11.3 → 2.1.0

package/server/handlers/handleConnect.test.ts

@@ -0,0 +1,589 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  AuthenticationResult,
+  MQTTLevel,
+  PacketType,
+  ReasonCode,
+} from "../deps.ts";
+import {
+  addMockClient,
+  connect,
+  connect5,
+  disconnect,
+  disconnect5,
+  ping,
+  publish,
+  startMockServer,
+  subscribe,
+} from "../../dev_utils/mod.ts";
+import { createConfiguration } from "../config.ts";
+
+const configuration = createConfiguration();
+const txtEncoder = new TextEncoder();
+
+test("Authentication with valid username and password works", async () => {
+  const { mqttConn } = startMockServer();
+  const connack = await connect(mqttConn);
+  assert.deepStrictEqual(
+    connack.returnCode,
+    AuthenticationResult.ok,
+    "Expected OK",
+  );
+  await disconnect(mqttConn);
+});
+
+test("Authentication with invalid username fails", async () => {
+  const { mqttConn } = startMockServer();
+  const connack = await connect(mqttConn, { username: "wrong" });
+
+  assert.deepStrictEqual(
+    connack.returnCode,
+    AuthenticationResult.badUsernameOrPassword,
+    "Expected badUsernameOrPassword",
+  );
+
+  await mqttConn.next();
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});
+
+test("Authentication with invalid password fails", async () => {
+  const { mqttConn } = startMockServer();
+  const connack = await connect(mqttConn, { password: "" });
+
+  assert.deepStrictEqual(
+    connack.returnCode,
+    AuthenticationResult.badUsernameOrPassword,
+    "Expected badUsernameOrPassword",
+  );
+
+  await mqttConn.next();
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});
+
+test("Two connect messages on same connection closes connection", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect(mqttConn);
+  assert.deepStrictEqual(
+    connack.returnCode,
+    AuthenticationResult.ok,
+    "Expected OK",
+  );
+
+  const connack2 = await connect(mqttConn, { checkAck: false });
+  assert.deepStrictEqual(connack2, undefined, "Expected no second connack");
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});
+
+test("Second session with same client id closes the first", async () => {
+  const clientId = "doubleClient";
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  // start first client
+  await connect(mqttConn1, { clientId });
+
+  // start second client with same id
+  const mqttConn2 = addMockClient(mqttServer);
+  await connect(mqttConn2, { clientId });
+
+  await mqttConn1.next();
+  assert.deepStrictEqual(
+    mqttConn1.isClosed,
+    true,
+    "Expected first connection to be closed",
+  );
+  assert.deepStrictEqual(
+    mqttConn2.isClosed,
+    false,
+    "Expected second connection not to be closed",
+  );
+  await disconnect(mqttConn2);
+});
+
+test("Redelivery on reconnect after failed delivery", async () => {
+  const clientId = "redeliveryClient";
+  const topic = "no/retained/here";
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  // start first client, clean needs to be false or else client state whill be wiped on disconnect
+  await connect(mqttConn1, { clientId, clean: false });
+  // Subscribe to topic with no retained message
+  await subscribe(mqttConn1, [{ topicFilter: topic, qos: 1 }]);
+  // the first packet returned will be the publish, not the ack.
+  await publish(mqttConn1, topic, 1, { checkAcks: false });
+  // first reception on our subscription
+  const { value: publishPacket } = await mqttConn1.next();
+  assert.deepStrictEqual(
+    publishPacket.type,
+    PacketType.publish,
+    "received publish packet again",
+  );
+  const publishId = publishPacket.id;
+  await mqttConn1.next(); // the puback on the publish we sent out
+  await disconnect(mqttConn1);
+  assert.deepStrictEqual(
+    mqttConn1.isClosed,
+    true,
+    "Expected first connection to be closed",
+  );
+  // connect again with same clientId
+  const mqttConn2 = addMockClient(mqttServer);
+  await connect(mqttConn2, { clientId, clean: false });
+  // expect published packet to be redelivered because we did not ack
+  const { value: packet } = await mqttConn2.next();
+  assert.deepStrictEqual(
+    packet.type,
+    PacketType.publish,
+    "received publish packet again",
+  );
+  assert.deepStrictEqual(
+    packet.id,
+    publishId,
+    "packetid is the same as on original delivery",
+  );
+  await disconnect(mqttConn2);
+});
+
+test("Delivery of messages with QoS 1 or QoS2 received while offline", async () => {
+  const clientId = "offlineClient";
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  // start first client
+  await connect(mqttConn1, { clientId, clean: false });
+  // Subscribe to topic with no retained message
+  await subscribe(mqttConn1, [{ topicFilter: "offline/+", qos: 1 }]);
+  // hangup
+  await disconnect(mqttConn1);
+
+  //  connect the publisher
+  const mqttConn2 = addMockClient(mqttServer);
+  await connect(mqttConn2, { clientId: "publisher" });
+  await publish(mqttConn2, "offline/q0", 0, { id: 10 });
+  await publish(mqttConn2, "offline/q1", 1, { id: 11 });
+  await publish(mqttConn2, "offline/q2", 2, { id: 12 });
+  await disconnect(mqttConn2);
+
+  // connect again with same clientId as the initial connect
+  const mqttConn3 = addMockClient(mqttServer);
+  await connect(mqttConn3, { clientId, clean: false });
+  // expect published packet that was delivered while offline
+  const { value: packetQos1 } = await mqttConn3.next();
+  assert.deepStrictEqual(
+    packetQos1.type,
+    PacketType.publish,
+    "received publish packet",
+  );
+  assert.deepStrictEqual(
+    packetQos1.topic,
+    "offline/q1",
+    "topic is expected",
+  );
+  const { value: packetQos2 } = await mqttConn3.next();
+  assert.deepStrictEqual(
+    packetQos2.type,
+    PacketType.publish,
+    "received publish packet",
+  );
+  assert.deepStrictEqual(
+    packetQos2.topic,
+    "offline/q2",
+    "topic is expected",
+  );
+  await ping(mqttConn3);
+  await disconnect(mqttConn3);
+});
+
+test("Delivery of messages with QoS 1 or QoS2 not received while offline when clean = true", async () => {
+  const clientId = "offlineClient";
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  // start first client
+  await connect(mqttConn1, { clientId, clean: true });
+  // Subscribe to topic with no retained message
+  await subscribe(mqttConn1, [{ topicFilter: "offline/+", qos: 1 }]);
+  // hangup
+  await disconnect(mqttConn1);
+
+  //  connect the publisher
+  const mqttConn2 = addMockClient(mqttServer);
+  await connect(mqttConn2, { clientId: "publisher" });
+  await publish(mqttConn2, "offline/q0", 0, { id: 10 });
+  await publish(mqttConn2, "offline/q1", 1, { id: 11 });
+  await publish(mqttConn2, "offline/q2", 2, { id: 12 });
+  await disconnect(mqttConn2);
+
+  // connect again with same clientId as the initial connect,but now with clean = false, just to check
+  const mqttConn3 = addMockClient(mqttServer);
+  await connect(mqttConn3, { clientId, clean: false });
+  // expect no published packet to be delivered while offline
+  await ping(mqttConn3);
+  await disconnect(mqttConn3);
+});
+
+test("V5: Connect V5 works", async () => {
+  const { mqttConn } = startMockServer();
+  const connack = await connect5(mqttConn, { clientId: "" });
+  assert.deepEqual(connack.reasonCode, 0, "Reason code 0 is expected");
+  const props = connack.properties;
+  const cfg = configuration.context;
+  assert.equal(
+    props?.maximumQos,
+    cfg.maximumQos,
+    "Props contain configuration data",
+  );
+  assert.equal(
+    props?.assignedClientIdentifier?.startsWith("Opifex-"),
+    true,
+    "Client identifier is assigned",
+  );
+
+  await disconnect5(mqttConn);
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5: Fails on unsupported protocol level and returns V5 ReasonCode", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { protocols: [MQTTLevel.v4] } },
+  });
+
+  const connack = await connect5(mqttConn, {
+    clientId: "v5Client",
+  });
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.unsupportedProtocolVersion,
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("Will Packet: Retain not supported returns retainNotSupported", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { retainAvailable: false } },
+  });
+
+  const connack = await connect(mqttConn, {
+    will: {
+      topic: "will/topic",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: true,
+    },
+  });
+
+  assert.strictEqual(
+    connack.returnCode,
+    AuthenticationResult.serverUnavailable,
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5 Will Packet: unauthorized will topic returns notAuthorized", async () => {
+  const { mqttConn } = startMockServer({
+    handlers: {
+      isAuthorizedToPublish: () => false,
+    },
+  });
+
+  const connack = await connect5(mqttConn, {
+    will: {
+      topic: "will/topic",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.notAuthorized,
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5 Will Packet: QoS exceeds maximumQos returns qosNotSupported", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { maximumQos: 1 } },
+  });
+
+  const connack = await connect5(mqttConn, {
+    will: {
+      topic: "will/topic",
+      payload: txtEncoder.encode("payload"),
+      qos: 2, // Exceeds max QoS 1
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.qosNotSupported,
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5 Will Packet: willDelayInterval greater than sessionExpiryInterval fails", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect5(mqttConn, {
+    clientId: "v5WillClient",
+    properties: {
+      sessionExpiryInterval: 100,
+    },
+    will: {
+      topic: "will/topic",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+      properties: {
+        willDelayInterval: 200, // Greater than sessionExpiryInterval (100)
+      },
+    },
+  });
+
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.payloadFormatInvalid,
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5: sessionExpiryInterval capped to maxSessionExpiryInterval", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { maxSessionExpiryInterval: 300 } },
+  });
+  const connack = await connect5(mqttConn, {
+    clientId: "cappedSessionClient",
+    clean: false,
+    properties: {
+      sessionExpiryInterval: 1000, // Greater than maxSessionExpiryInterval (300)
+    },
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.success);
+  assert.strictEqual(connack.properties?.sessionExpiryInterval, 300);
+
+  await disconnect5(mqttConn);
+});
+
+test("V5: Reason string returned in properties when provideReasonStrings is true", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: {
+      context: {
+        provideReasonStrings: true,
+        protocols: [MQTTLevel.v4],
+      },
+    },
+  });
+  const connack = await connect5(mqttConn, {});
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.unsupportedProtocolVersion,
+  );
+  assert.strictEqual(
+    connack.properties?.reasonString,
+    "Protocol version 5 is not supported",
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("reasonToReturnCode branch coverage for V4 status mappings", async () => {
+  const testCases = [
+    {
+      reasonCode: ReasonCode.clientIdentifierNotValid,
+      expectedReturnCode: AuthenticationResult.rejectedUsername,
+    },
+    {
+      reasonCode: ReasonCode.badAuthenticationMethod,
+      expectedReturnCode: AuthenticationResult.badUsernameOrPassword,
+    },
+    {
+      reasonCode: ReasonCode.banned,
+      expectedReturnCode: AuthenticationResult.notAuthorized,
+    },
+    {
+      reasonCode: ReasonCode.packetIdentifierNotFound, // Unmapped fallback
+      expectedReturnCode: AuthenticationResult.serverUnavailable,
+    },
+  ];
+
+  for (const tc of testCases) {
+    const { mqttConn } = startMockServer({
+      handlers: {
+        isAuthenticated: () => ({ reasonCode: tc.reasonCode }),
+      },
+    });
+
+    const connack = await connect(mqttConn);
+    assert.strictEqual(
+      connack.returnCode,
+      tc.expectedReturnCode,
+      `ReasonCode ${tc.reasonCode} should map to returnCode ${tc.expectedReturnCode}`,
+    );
+
+    await mqttConn.next();
+    assert.strictEqual(mqttConn.isClosed, true);
+  }
+});
+
+test("Will Packet: Empty topic fails with topicNameInvalid", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect5(mqttConn, {
+    will: {
+      topic: "",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.topicNameInvalid);
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("Will Packet: Invalid wildcard topic filter fails validation", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect5(mqttConn, {
+    will: {
+      topic: "invalid/+/will",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.topicNameInvalid);
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("Will Packet: Topic level count exceeding maxTopicLevels fails validation", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: { context: { maxTopicLevels: 1 } },
+  });
+
+  const connack = await connect5(mqttConn, {
+    will: {
+      topic: "level1/level2", // 2 levels exceeds limit of 1
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.topicNameInvalid);
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V4 Will Packet: Unauthorized Will topic maps to V4 returnCode", async () => {
+  const { mqttConn } = startMockServer({
+    handlers: {
+      isAuthorizedToPublish: () => false,
+    },
+  });
+
+  const connack = await connect(mqttConn, {
+    will: {
+      topic: "unauthorized/will",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+    },
+  });
+
+  assert.strictEqual(
+    connack.returnCode,
+    AuthenticationResult.notAuthorized,
+  );
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});
+
+test("V5 Will Packet: Valid willDelayInterval when sessionExpiryInterval is omitted or sufficient", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect5(mqttConn, {
+    properties: {
+      sessionExpiryInterval: 300,
+    },
+    will: {
+      topic: "will/topic",
+      payload: txtEncoder.encode("payload"),
+      qos: 0,
+      retain: false,
+      properties: {
+        willDelayInterval: 100, // Valid since 100 <= 300
+      },
+    },
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.success);
+  await disconnect5(mqttConn);
+});
+
+test("V5: Assigned clientId omitted from CONNACK when client provides explicit clientId", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect5(mqttConn, {
+    clientId: "explicit-client-id",
+  });
+
+  assert.strictEqual(connack.reasonCode, ReasonCode.success);
+  assert.strictEqual(
+    connack.properties?.assignedClientIdentifier,
+    undefined,
+    "Expected assignedClientIdentifier to be omitted",
+  );
+
+  await disconnect5(mqttConn);
+});
+
+test("V5: Reason string omitted when provideReasonStrings is false", async () => {
+  const { mqttConn } = startMockServer({
+    configuration: {
+      context: {
+        provideReasonStrings: false,
+        protocols: [MQTTLevel.v4], // Force failure to evaluate error properties
+      },
+    },
+  });
+
+  const connack = await connect5(mqttConn, {});
+  assert.strictEqual(
+    connack.reasonCode,
+    ReasonCode.unsupportedProtocolVersion,
+  );
+  assert.strictEqual(
+    connack.properties?.reasonString,
+    undefined,
+    "Reason string should be omitted when provideReasonStrings is false",
+  );
+
+  await mqttConn.next();
+  assert.strictEqual(mqttConn.isClosed, true);
+});