Added tests for base 128 encoding/decoding and lexicographic order

Author: CMCDragonkai

tests/utils.test.ts

@@ -1,5 +1,7 @@
 import type { KeyPath } from '@/types';
+import nodeCrypto from 'crypto';
 import * as utils from '@/utils';
+import * as testUtils from './utils';
 
 describe('utils', () => {
   const keyPaths: Array<KeyPath> = [
@@ -91,4 +93,96 @@ describe('utils', () => {
       );
     },
   );
+  test('base128 encoding/decoding', () => {
+    // Base 128 alphabet is alphabetical and starts at 0x01 (skips 0x00)
+    // it uses the same rfc4648 algorithm that base64 uses
+    const table = [
+      [[], []],
+      [[0x00], [0x01, 0x01]],
+      [[0x01], [0x01, 0x41]],
+      [[0x02], [0x02, 0x01]],
+      [[0x03], [0x02, 0x41]],
+      [[0x04], [0x03, 0x01]],
+      [[0x05], [0x03, 0x41]],
+      [[0x06], [0x04, 0x01]],
+      [[0x07], [0x04, 0x41]],
+      [[0x08], [0x05, 0x01]],
+      // Larger single bytes
+      [[0xec], [0x77, 0x01]],
+      [[0xed], [0x77, 0x41]],
+      [[0xee], [0x78, 0x01]],
+      [[0xef], [0x78, 0x41]],
+      [[0xfe], [0x80, 0x01]],
+      [[0xff], [0x80, 0x41]],
+      // 2 bytes
+      [
+        [0x00, 0x00],
+        [0x01, 0x01, 0x01],
+      ],
+      [
+        [0x00, 0x01],
+        [0x01, 0x01, 0x21],
+      ],
+      [
+        [0xfe, 0x00],
+        [0x80, 0x01, 0x01],
+      ],
+      [
+        [0xfe, 0x01],
+        [0x80, 0x01, 0x21],
+      ],
+      [
+        [0xff, 0x00],
+        [0x80, 0x41, 0x01],
+      ],
+      [
+        [0xff, 0x01],
+        [0x80, 0x41, 0x21],
+      ],
+      [
+        [0xff, 0xff],
+        [0x80, 0x80, 0x61],
+      ],
+    ];
+    for (const [input, output] of table) {
+      const inputEncoded = utils.encodePart(Buffer.from(input));
+      expect(inputEncoded).toStrictEqual(Buffer.from(output));
+      const inputEncodedDecoded = utils.decodePart(inputEncoded);
+      expect(inputEncodedDecoded).toStrictEqual(Buffer.from(input));
+    }
+  });
+  test('base128 preserves lexicographic order', () => {
+    const parts: Array<[number, Buffer]> = Array.from(
+      { length: 1000 },
+      (_, i) => [i, nodeCrypto.randomBytes(testUtils.getRandomInt(0, 101))],
+    );
+    const partsEncoded: Array<[number, Buffer]> = parts.map(([i, p]) => [
+      i,
+      utils.encodePart(p),
+    ]);
+    parts.sort(([_i, a], [_j, b]) => Buffer.compare(a, b));
+    partsEncoded.sort(([_i, a], [_j, b]) => Buffer.compare(a, b));
+    expect(parts.map(([i]) => i)).toStrictEqual(partsEncoded.map(([i]) => i));
+    for (const [j, [i, pE]] of partsEncoded.entries()) {
+      expect([i, utils.decodePart(pE)]).toStrictEqual(parts[j]);
+    }
+  });
+  test('Buffer.compare sorts byte by byte', () => {
+    const arr = [
+      Buffer.from([]),
+      Buffer.from([0x01]),
+      Buffer.from([0x00, 0x00, 0x00]),
+      Buffer.from([0x00, 0x00]),
+    ];
+    arr.sort(Buffer.compare);
+    expect(arr).toStrictEqual([
+      // Therefore empty buffer sorts first
+      Buffer.from([]),
+      Buffer.from([0x00, 0x00]),
+      // Therefore `aa` is earlier than `aaa`
+      Buffer.from([0x00, 0x00, 0x00]),
+      // Therefore `aa` is earlier than `z`
+      Buffer.from([0x01]),
+    ]);
+  });
 });

tests/utils.ts

@@ -3,6 +3,16 @@ import { random, cipher, util as forgeUtil } from 'node-forge';
 const ivSize = 16;
 const authTagSize = 16;
 
+/**
+ * Get a random integer between min and max
+ * Returned value greater or equal to min and less than max
+ */
+function getRandomInt(min: number, max: number): number {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min) + min); // The maximum is exclusive and the minimum is inclusive
+}
+
 async function getRandomBytes(size: number): Promise<Buffer> {
   const p = new Promise<string>((resolve, reject) => {
     random.getBytes(size, (e, bytes) => {
@@ -108,6 +118,7 @@ function bytes2BigInt(bytes: Uint8Array): bigint {
 }
 
 export {
+  getRandomInt,
   getRandomBytes,
   getRandomBytesSync,
   generateKey,