@seriousme/opifex 1.9.3 → 1.10.1

package/mqttPacket/publishAcks.test.ts

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts, TPacketType, TReasonCode } from "./mod.ts";
+
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const packetTypesToTest = [
+  [PacketType.puback, "Puback", ReasonCode.packetIdentifierInUse],
+  [PacketType.pubrec, "Pubrec", ReasonCode.packetIdentifierInUse],
+  [PacketType.pubrel, "Pubrel", ReasonCode.packetIdentifierNotFound],
+  [PacketType.pubcomp, "Pubcomp", ReasonCode.packetIdentifierNotFound],
+];
+for (const item of packetTypesToTest) {
+  const [ackType, label, reasonCode] = item as [
+    TPacketType,
+    string,
+    TReasonCode,
+  ];
+  const ackTypeByte = (ackType << 4) + (ackType === PacketType.pubrel ? 2 : 0);
+  test(`encode/decode ${label} v4`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v4,
+      id: 1337,
+    };
+    const encoded = encode(packet, codecOptsV4);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV4);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test(`encode/decode ${label} v5`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v5,
+      id: 1337,
+      reasonCode,
+      properties: { reasonString: "test" },
+    };
+    const encoded = encode(packet, codecOptsV5);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        11, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+        reasonCode, // reasonCode
+        // properties
+        7, // propertyLength
+        31, // reasonString
+        0, // string length MSB
+        4, // string length LSB
+        116, //'t'
+        101, //'e'
+        115, //'s'
+        116, //'t'
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV5);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test(`encode/decode short ${label} v5`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v5,
+      id: 1337,
+      reasonCode: 0,
+    };
+    const encoded = encode(packet, codecOptsV5);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV5);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test("decode short puback packets", () => {
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte]), codecOptsV4),
+      Error,
+      "decoding failed",
+    );
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte, 3, 0, 0, 0]), codecOptsV4),
+      Error,
+      "too long",
+    );
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte, 2, 5]), codecOptsV5),
+      Error,
+      "decoding failed",
+    );
+  });
+}

package/mqttPacket/suback.test.ts

@@ -1,16 +1,30 @@
-import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
-import { decode, encode } from "./mod.ts";
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
 
-test("encode Suback", () => {
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Suback v4", () => {
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: MQTTLevel.v4,
+    id: 1,
+    returnCodes: [0, 1],
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.suback,
-      id: 1,
-      returnCodes: [0, 1],
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       0x90, // packetType + flags
@@ -23,27 +37,57 @@ test("encode Suback", () => {
       1,
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode Suback", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        0x90, // packetType + flags
-        4, // remainingLength
-        // variableHeader
-        0, // id MSB
-        1, // id LSB
-        // payload
-        0,
-        1,
-      ]),
-    ),
-    {
-      type: PacketType.suback,
-      id: 1,
-      returnCodes: [0, 1],
+test("encode/decode Suback v5", () => {
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: MQTTLevel.v5,
+    id: 1,
+    reasonCodes: [ReasonCode.grantedQos0, ReasonCode.grantedQos1],
+    properties: {
+      reasonString: "reason",
+      userProperty: [["test", "test"]],
     },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      144, // packetType + flags
+      27, // remaining length
+      0, // id MSB
+      1, // id LSB
+      22, // propertysize
+      31, // reason string
+      0, // string length MSB
+      6, // string length LSB
+      114, // r
+      101, // e
+      97, // a
+      115, // s
+      111, // o
+      110, // n
+      38, // user property
+      0, // string length MSB
+      4, // string length LSB
+      116, // t
+      101, // e
+      115, // s
+      116, // t
+      0, // string length MSB
+      4, // string length LSB
+      116, // t
+      101, // e
+      115, // s
+      116, // t
+      0, // return code
+      1, // return code
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
 });

package/mqttPacket/suback.ts

@@ -1,48 +1,100 @@
-import type { PacketId, ReturnCodes, TPacketType } from "./types.ts";
+import type {
+  CodecOpts,
+  PacketId,
+  ProtocolLevelNoV5,
+  ReturnCodes,
+  TPacketType,
+  TReasonCode,
+} from "./types.ts";
+import type { SubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Encoder } from "./encoder.ts";
-import { Decoder } from "./decoder.ts";
+import { Decoder, DecoderError } from "./decoder.ts";
+const validReturnCodes = [0x00, 0x01, 0x02, 0x80];
 
 /**
  * SubackPacket is sent by the server to the client to confirm receipt and
  * processing of a SubscribePacket.
  */
-export type SubackPacket = {
+export type SubackPacketV4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
   returnCodes: ReturnCodes;
 };
 
+export type SubackPacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  id: PacketId;
+  properties: SubackProperties;
+  reasonCodes: Array<TReasonCode>;
+};
+
+export type SubackPacket = SubackPacketV4 | SubackPacketV5;
+
 export const suback: {
-  encode(packet: SubackPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array): SubackPacket;
+  encode(packet: SubackPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubackPacket;
 } = {
-  encode(packet: SubackPacket): { flags: number; bytes: number[] } {
+  encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
     const flags = 0;
-    const encoder = new Encoder();
+    const encoder = new Encoder(packet.type);
     encoder.setInt16(packet.id);
-    encoder.setRemainder(packet.returnCodes);
-
-    return {
-      flags,
-      bytes: encoder.done(),
-    };
+    if (packet.protocolLevel !== 5) {
+      for (const code of packet.returnCodes) {
+        if (!validReturnCodes.includes(code)) {
+          throw new Error("Invalid return code");
+        }
+      }
+      encoder.setRemainder(packet.returnCodes);
+      return encoder.done(flags);
+    }
+    encoder.setProperties(
+      packet.properties || {},
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+    for (const code of packet.reasonCodes) {
+      encoder.setReasonCode(code);
+    }
+    return encoder.done(flags);
   },
 
-  decode(buffer: Uint8Array): SubackPacket {
-    const decoder = new Decoder(buffer);
-    const id = decoder.getInt16();
-    const payload = decoder.getRemainder();
-    const returnCodes = [];
+  decode(
+    buffer: Uint8Array,
+    _flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubackPacket {
+    const packet = {} as SubackPacket;
+    const decoder = new Decoder(packetType, buffer);
+    packet.type = PacketType.suback;
+    packet.id = decoder.getInt16();
+    packet.protocolLevel = codecOpts.protocolLevel;
 
-    for (const code of payload) {
-      returnCodes.push(code);
+    if (packet.protocolLevel !== 5) {
+      const payload = decoder.getRemainder();
+      packet.returnCodes = [];
+      for (const code of payload) {
+        if (!validReturnCodes.includes(code)) {
+          throw new DecoderError("Invalid return code");
+        }
+        packet.returnCodes.push(code);
+      }
+      return packet;
     }
-
-    return {
-      type: PacketType.suback,
-      id,
-      returnCodes,
-    };
+    packet.properties = decoder.getProperties(PacketType.suback);
+    packet.reasonCodes = [];
+    while (!decoder.atEnd()) {
+      const code = decoder.getReasonCode();
+      packet.reasonCodes.push(code);
+    }
+    return packet;
   },
 };

package/mqttPacket/subscribe.test.ts

@@ -2,18 +2,34 @@ import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
-import { decode, encode } from "./mod.ts";
+import { decode, encode, MQTTLevel, RetainHandling } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
-test("encode Subscribe", () => {
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Subscribe v4", () => {
+  const packet = {
+    type: PacketType.subscribe,
+    protocolLevel: MQTTLevel.v4,
+    id: 1,
+    subscriptions: [
+      { topicFilter: "a/b", qos: 0 },
+      { topicFilter: "c/d", qos: 1 },
+    ],
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.subscribe,
-      id: 1,
-      subscriptions: [
-        { topicFilter: "a/b", qos: 0 },
-        { topicFilter: "c/d", qos: 1 },
-      ],
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       0x82, // packetType + flags
@@ -36,45 +52,75 @@ test("encode Subscribe", () => {
       1, // qos
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode Subscribe", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        0x82, // packetType + flags
-        14, // remainingLength
-        // variableHeader
-        0, // id MSB
-        1, // id LSB
-        // payload
-        0, // topic filter length MSB
-        3, // topic filter length LSB
-        97, // 'a'
-        47, // '/'
-        98, // 'b'
-        0, // qos
-        0, // topic filter length MSB
-        3, // topic filter length LSB
-        99, // 'c'
-        47, // '/'
-        100, // 'd'
-        1, // qos
-      ]),
-    ),
-    {
-      type: PacketType.subscribe,
-      id: 1,
-      subscriptions: [
-        { topicFilter: "a/b", qos: 0 },
-        { topicFilter: "c/d", qos: 1 },
-      ],
+test("encode/decode Subscribe v5", () => {
+  const packet = {
+    type: PacketType.subscribe,
+    protocolLevel: MQTTLevel.v5,
+    id: 1,
+    subscriptions: [
+      { topicFilter: "a/b", qos: 0 },
+      {
+        topicFilter: "c/d",
+        qos: 2,
+        noLocal: true,
+        retainAsPublished: true,
+        retainHandling: RetainHandling.noRetain,
+      },
+    ],
+    properties: {
+      subscriptionIdentifier: 123,
     },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      0x82, // packetType + flags
+      17, // remainingLength
+      // variableHeader
+      0, // id MSB
+      1, // id LSB
+      2, // propertyLength
+      11, // subscription identifier
+      123, // 123
+      // payload
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      97, // 'a'
+      47, // '/'
+      98, // 'b'
+      0, // options
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      99, // 'c'
+      47, // '/'
+      100, // 'd'
+      46, // options 0b101110
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  // add the defaults for comparison
+  const packetWithDefaults = {
+    ...packet,
+    subscriptions: [
+      {
+        ...packet.subscriptions[0],
+        noLocal: false,
+        retainAsPublished: false,
+        retainHandling: RetainHandling.sendRetained,
+      },
+      { ...packet.subscriptions[1] },
+    ],
+  };
+  assert.deepStrictEqual(decoded, packetWithDefaults);
 });
 
-test("decode Subscribe missing bit 1 flag", () => {
+test("decode Subscribe v4 missing bit 1 flag", () => {
   assert.throws(
     () =>
       decode(
@@ -99,6 +145,7 @@ test("decode Subscribe missing bit 1 flag", () => {
           100, // 'd'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid header",
@@ -129,6 +176,7 @@ test("decode Subscribe packet too short", () => {
           47, // '/'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid qos",
@@ -154,6 +202,7 @@ test("decode Subscribe packet too short", () => {
           3, // topic filter length LSB
           99, // 'c'
         ]),
+        codecOptsV4,
       ),
     Error,
     "too short",
@@ -169,6 +218,7 @@ test("decode Subscribe packet too short", () => {
           0, // id MSB
           1, // id LSB
         ]),
+        codecOptsV4,
       ),
     Error,
     "too short",
@@ -199,6 +249,7 @@ test("decode Subscribe packet invalid packet id with QoS > 0", () => {
           47, // '/'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid packet identifier",
@@ -226,8 +277,46 @@ test("decode Subscribe packet invalid packet id with QoS > 0", () => {
           47, // '/'
           2, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid packet identifier",
   );
 });
+
+test("decode Subscribe v5 with invalid subscription options", () => {
+  for (
+    const item of [
+      [0b10000000, /Invalid subscription options/], // bit 7 must be 0
+      [0b1000000, /Invalid subscription options/], // bit 6 must be 0
+      [0b110000, /Invalid retain handling/], // retain handling can't be 3
+      [0b100011, /Invalid qos/], // qos can't be 3
+    ]
+  ) {
+    const [options, err] = item as [number, RegExp];
+    assert.throws(
+      () =>
+        decode(
+          Uint8Array.from([
+            // fixedHeader
+            0x82, // packetType + flags
+            9, // remainingLength
+            // variableHeader
+            0, // id MSB
+            1, // id LSB
+            0, // propertyLength
+            // payload
+            0, // topic filter length MSB
+            3, // topic filter length LSB
+            97, // 'a'
+            47, // '/'
+            98, // 'b'
+            options, // options
+          ]),
+          codecOptsV5,
+        ),
+      err,
+      "Invalid subscription options",
+    );
+  }
+});