add tests

Author: supersuryaansh

package.json

@@ -8,12 +8,13 @@
   "main": "index.js",
   "scripts": {
     "format": "prettier . --write",
-    "test": "prettier . --check"
+    "test": "prettier . --check && node test.js"
   },
   "dependencies": {
     "bare-encoding": "^1.0.3"
   },
   "devDependencies": {
+    "brittle": "^4.0.0",
     "prettier": "^3.8.3",
     "prettier-config-holepunch": "^2.0.0"
   }

test.js

@@ -0,0 +1,189 @@
+const test = require('brittle')
+const {
+  CAPABILITY_LEN,
+  HEADER_LEN,
+  MODE_TUNNEL,
+  MODE_PROBE,
+  encodeHeader,
+  decodeHeader,
+  encodeProbeResponse,
+  decodeProbeResponse
+} = require('./index.js')
+
+test('constants', function (t) {
+  t.is(CAPABILITY_LEN, 32)
+  t.is(HEADER_LEN, 33)
+  t.is(MODE_TUNNEL, 0)
+  t.is(MODE_PROBE, 1)
+})
+
+test('encodeHeader - tunnel mode', function (t) {
+  const cap = Buffer.alloc(32, 0xab)
+  const header = encodeHeader(cap, MODE_TUNNEL)
+
+  t.is(header.length, HEADER_LEN)
+  t.alike(Buffer.from(header.subarray(0, 32)), cap)
+  t.is(header[32], MODE_TUNNEL)
+})
+
+test('encodeHeader - probe mode', function (t) {
+  const cap = Buffer.alloc(32, 0xff)
+  const header = encodeHeader(cap, MODE_PROBE)
+
+  t.is(header[32], MODE_PROBE)
+})
+
+test('encodeHeader - rejects wrong capability length', function (t) {
+  t.exception(() => encodeHeader(Buffer.alloc(16), 0), /capability must be 32 bytes/)
+  t.exception(() => encodeHeader(Buffer.alloc(0), 0), /capability must be 32 bytes/)
+  t.exception(() => encodeHeader(Buffer.alloc(64), 0), /capability must be 32 bytes/)
+})
+
+test('encodeHeader - rejects invalid mode', function (t) {
+  const cap = Buffer.alloc(32)
+  t.exception(() => encodeHeader(cap, -1), /mode must be a byte/)
+  t.exception(() => encodeHeader(cap, 256), /mode must be a byte/)
+  t.exception(() => encodeHeader(cap, 1.5), /mode must be a byte/)
+  t.exception(() => encodeHeader(cap, NaN), /mode must be a byte/)
+})
+
+test('decodeHeader - round trip', function (t) {
+  const cap = Buffer.alloc(32)
+  for (let i = 0; i < 32; i++) cap[i] = i
+
+  const encoded = encodeHeader(cap, MODE_PROBE)
+  const decoded = decodeHeader(encoded)
+
+  t.alike(Buffer.from(decoded.capability), cap)
+  t.is(decoded.mode, MODE_PROBE)
+  t.is(decoded.leftover.length, 0)
+})
+
+test('decodeHeader - with leftover bytes', function (t) {
+  const cap = Buffer.alloc(32, 0x01)
+  const header = encodeHeader(cap, MODE_TUNNEL)
+  const extra = Buffer.from([0xde, 0xad])
+  const combined = Buffer.concat([header, extra])
+
+  const decoded = decodeHeader(combined)
+  t.alike(decoded.leftover, extra)
+})
+
+test('decodeHeader - returns null on short input', function (t) {
+  t.is(decodeHeader(Buffer.alloc(0)), null)
+  t.is(decodeHeader(Buffer.alloc(32)), null)
+})
+
+test('encodeProbeResponse - defaults', function (t) {
+  const probe = encodeProbeResponse()
+
+  t.is(probe[0], 0)
+  t.is(probe[1], 0)
+  t.is(probe[2], 0)
+  t.is(probe[3], 0)
+  t.is(probe.length, 4)
+})
+
+test('encodeProbeResponse - with host and port', function (t) {
+  const probe = encodeProbeResponse({ port: 8080, host: '127.0.0.1' })
+
+  t.is((probe[0] << 8) | probe[1], 8080)
+  t.is(probe[2], 0)
+  t.is(probe[3], 9)
+  t.is(probe.length, 4 + 9)
+})
+
+test('encodeProbeResponse - udp flag', function (t) {
+  const probe = encodeProbeResponse({ udp: true })
+  t.is(probe[2], 1)
+
+  const probe2 = encodeProbeResponse({ udp: false })
+  t.is(probe2[2], 0)
+})
+
+test('encodeProbeResponse - rejects host over 255 bytes', function (t) {
+  const longHost = 'a'.repeat(256)
+  t.exception(() => encodeProbeResponse({ host: longHost }), /host exceeds 255 bytes/)
+})
+
+test('encodeProbeResponse - rejects invalid port', function (t) {
+  t.exception(() => encodeProbeResponse({ port: -1 }), /port must fit in uint16/)
+  t.exception(() => encodeProbeResponse({ port: 0x10000 }), /port must fit in uint16/)
+})
+
+test('decodeProbeResponse - round trip', function (t) {
+  const original = { port: 443, host: 'example.com', udp: false }
+  const encoded = encodeProbeResponse(original)
+  const decoded = decodeProbeResponse(encoded)
+
+  t.is(decoded.port, 443)
+  t.is(decoded.host, 'example.com')
+  t.is(decoded.udp, false)
+  t.is(decoded.leftover.length, 0)
+})
+
+test('decodeProbeResponse - udp round trip', function (t) {
+  const encoded = encodeProbeResponse({ port: 53, host: '8.8.8.8', udp: true })
+  const decoded = decodeProbeResponse(encoded)
+
+  t.is(decoded.port, 53)
+  t.is(decoded.host, '8.8.8.8')
+  t.is(decoded.udp, true)
+})
+
+test('decodeProbeResponse - with leftover bytes', function (t) {
+  const encoded = encodeProbeResponse({ port: 80, host: 'localhost' })
+  const extra = Buffer.from([0x01, 0x02, 0x03])
+  const combined = Buffer.concat([encoded, extra])
+
+  const decoded = decodeProbeResponse(combined)
+  t.alike(decoded.leftover, extra)
+})
+
+test('decodeProbeResponse - returns null on short input', function (t) {
+  t.is(decodeProbeResponse(Buffer.alloc(0)), null)
+  t.is(decodeProbeResponse(Buffer.alloc(3)), null)
+})
+
+test('decodeProbeResponse - returns null when host is truncated', function (t) {
+  const buf = Buffer.from([0x00, 0x50, 0x00, 0x05, 0x61])
+  t.is(decodeProbeResponse(buf), null)
+})
+
+test('full header + probe round trip', function (t) {
+  const cap = Buffer.alloc(32, 0xcc)
+  const header = encodeHeader(cap, MODE_PROBE)
+  const probe = encodeProbeResponse({ port: 9999, host: '10.0.0.1', udp: true })
+  const wire = Buffer.concat([header, probe])
+
+  const h = decodeHeader(wire)
+  t.is(h.mode, MODE_PROBE)
+  t.alike(h.capability, cap)
+
+  const p = decodeProbeResponse(h.leftover)
+  t.is(p.port, 9999)
+  t.is(p.host, '10.0.0.1')
+  t.is(p.udp, true)
+  t.is(p.leftover.length, 0)
+})
+
+test('encodeProbeResponse - empty host', function (t) {
+  const encoded = encodeProbeResponse({ port: 1234, host: '' })
+  const decoded = decodeProbeResponse(encoded)
+
+  t.is(decoded.port, 1234)
+  t.is(decoded.host, '')
+})
+
+test('encodeProbeResponse - max valid port', function (t) {
+  const encoded = encodeProbeResponse({ port: 65535 })
+  const decoded = decodeProbeResponse(encoded)
+
+  t.is(decoded.port, 65535)
+})
+
+test('encodeHeader - max valid mode byte', function (t) {
+  const cap = Buffer.alloc(32)
+  const header = encodeHeader(cap, 255)
+  t.is(header[32], 255)
+})