feat: enhance tests for socket functionality and add ICMP checksum tests

Author: derevnjuk

.github/workflows/test.yml

@@ -23,11 +23,21 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
 
+      # unfortunately, raw sockets require elevated privileges to run tests, and neither capabilities nor sudo are supported on Linux runners
+      - name: Set raw socket capability (Linux)
+        if: runner.os == 'Linux'
+        run: sudo setcap cap_net_raw,cap_net_admin,cap_net_bind_service+eip $(which node)
+
       - name: Install dependencies
         run: npm ci
 
       - name: Build
         run: npm run build
 
+      - name: Run tests (Mac)
+        if: runner.os == 'macOS'
+        run: sudo npm test
+      
       - name: Run tests
+        if: runner.os != 'macOS'
         run: npm test

test/e2e/byte-order-extended.test.mjs

@@ -0,0 +1,167 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { htonl, htons, ntohl, ntohs } from '../../index.mjs';
+
+describe('byte order conversions', () => {
+    it('should convert 0x1234 with htons', () => {
+      // arrange
+      const value = 0x1234;
+
+      // act
+      const result = htons(value);
+
+      // assert
+      assert.strictEqual(typeof result, 'number');
+    });
+
+    it('should convert 0x1234 back with ntohs after htons', () => {
+      // arrange
+      const original = 0x1234;
+
+      // act
+      const result = ntohs(htons(original));
+
+      // assert
+      assert.strictEqual(result, original);
+    });
+
+    it('should handle port number conversion (80)', () => {
+      // arrange
+      const httpPort = 80;
+
+      // act
+      const networkOrder = htons(httpPort);
+      const hostOrder = ntohs(networkOrder);
+
+      // assert
+      assert.strictEqual(hostOrder, httpPort);
+    });
+
+    it('should handle port number conversion (443)', () => {
+      // arrange
+      const httpsPort = 443;
+
+      // act
+      const networkOrder = htons(httpsPort);
+      const hostOrder = ntohs(networkOrder);
+
+      // assert
+      assert.strictEqual(hostOrder, httpsPort);
+    });
+
+    it('should handle max 16-bit value', () => {
+      // arrange
+      const maxValue = 0xffff;
+
+      // act
+      const result = ntohs(htons(maxValue));
+
+      // assert
+      assert.strictEqual(result, maxValue);
+    });
+
+    it('should handle zero', () => {
+      // arrange
+      const zero = 0;
+
+      // act
+      const result = ntohs(htons(zero));
+
+      // assert
+      assert.strictEqual(result, zero);
+    });
+
+    it('should convert 0x12345678 with htonl', () => {
+      // arrange
+      const value = 0x12345678;
+
+      // act
+      const result = htonl(value);
+
+      // assert
+      assert.strictEqual(typeof result, 'number');
+    });
+
+    it('should convert 0x12345678 back with ntohl after htonl', () => {
+      // arrange
+      const original = 0x12345678;
+
+      // act
+      const result = ntohl(htonl(original));
+
+      // assert
+      assert.strictEqual(result, original);
+    });
+
+    it('should handle IPv4 address conversion (192.168.1.1)', () => {
+      // arrange
+      const ipAddress = ((192 << 24) | (168 << 16) | (1 << 8) | 1) >>> 0;
+
+      // act
+      const networkOrder = htonl(ipAddress);
+      const hostOrder = ntohl(networkOrder);
+
+      // assert
+      assert.strictEqual(hostOrder >>> 0, ipAddress >>> 0);
+    });
+
+    it('should handle IPv4 address conversion (127.0.0.1)', () => {
+      // arrange
+      const localhost = (127 << 24) | (0 << 16) | (0 << 8) | 1;
+
+      // act
+      const networkOrder = htonl(localhost);
+      const hostOrder = ntohl(networkOrder);
+
+      // assert
+      assert.strictEqual(hostOrder, localhost);
+    });
+
+    it('should handle max 32-bit value', () => {
+      // arrange
+      const maxValue = 0xffffffff;
+
+      // act
+      const result = ntohl(htonl(maxValue));
+
+      // assert
+      assert.strictEqual(result >>> 0, maxValue >>> 0);
+    });
+
+    it('should handle zero', () => {
+      // arrange
+      const zero = 0;
+
+      // act
+      const result = ntohl(htonl(zero));
+
+      // assert
+      assert.strictEqual(result, zero);
+    });
+
+    it('should be idempotent for double conversion (htons)', () => {
+      // arrange
+      const original = 0x1234;
+
+      // act
+      const once = htons(original);
+      const twice = htons(htons(original));
+      const back = ntohs(ntohs(twice));
+
+      // assert
+      assert.strictEqual(back, original);
+    });
+
+    it('should be idempotent for double conversion (htonl)', () => {
+      // arrange
+      const original = 0x12345678;
+
+      // act
+      const once = htonl(original);
+      const twice = htonl(htonl(original));
+      const back = ntohl(ntohl(twice));
+
+      // assert
+      assert.strictEqual(back, original);
+    });
+});

test/e2e/cjs-compat.test.mjs

@@ -4,7 +4,7 @@ import assert from 'node:assert';
 describe('cjs import', () => {
   it('should be importable via require', async () => {
     // act
-    const module = await import('../../index.js');
+    const module = await import('../../index.cjs');
 
     // assert
     assert.ok(module);
@@ -20,7 +20,7 @@ describe('cjs import', () => {
   it('should have same exports as esm', async () => {
     // arrange
     const esm = await import('../../index.mjs');
-    const cjs = await import('../../index.js');
+    const cjs = await import('../../index.cjs');
     const keysToIgnore = ['default', 'module.exports'];
 
     // act

test/e2e/constants.test.mjs

@@ -0,0 +1,125 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { AddressFamily, Protocol, SocketLevel, SocketOption } from '../../index.mjs';
+
+describe('AddressFamily', () => {
+  it('should have IPv4 mapped to 1', () => {
+    // assert
+    assert.strictEqual(AddressFamily.IPv4, 1);
+  });
+
+  it('should have IPv6 mapped to 2', () => {
+    // assert
+    assert.strictEqual(AddressFamily.IPv6, 2);
+  });
+
+  it('should have reverse mapping for IPv4', () => {
+    // assert
+    assert.strictEqual(AddressFamily[1], 'IPv4');
+  });
+
+  it('should have reverse mapping for IPv6', () => {
+    // assert
+    assert.strictEqual(AddressFamily[2], 'IPv6');
+  });
+});
+
+describe('Protocol', () => {
+  it('should have None mapped to 0', () => {
+    // assert
+    assert.strictEqual(Protocol.None, 0);
+  });
+
+  it('should have ICMP mapped to 1', () => {
+    // assert
+    assert.strictEqual(Protocol.ICMP, 1);
+  });
+
+  it('should have TCP mapped to 6', () => {
+    // assert
+    assert.strictEqual(Protocol.TCP, 6);
+  });
+
+  it('should have UDP mapped to 17', () => {
+    // assert
+    assert.strictEqual(Protocol.UDP, 17);
+  });
+
+  it('should have ICMPv6 mapped to 58', () => {
+    // assert
+    assert.strictEqual(Protocol.ICMPv6, 58);
+  });
+
+  it('should have reverse mappings', () => {
+    // assert
+    assert.strictEqual(Protocol[0], 'None');
+    assert.strictEqual(Protocol[1], 'ICMP');
+    assert.strictEqual(Protocol[6], 'TCP');
+    assert.strictEqual(Protocol[17], 'UDP');
+    assert.strictEqual(Protocol[58], 'ICMPv6');
+  });
+});
+
+describe('SocketLevel', () => {
+  it('should have IPPROTO_IP defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketLevel.IPPROTO_IP, 'number');
+  });
+
+  it('should have IPPROTO_IPV6 defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketLevel.IPPROTO_IPV6, 'number');
+  });
+
+  it('should have SOL_SOCKET defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketLevel.SOL_SOCKET, 'number');
+  });
+});
+
+describe('SocketOption', () => {
+  it('should have IP_TTL defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IP_TTL, 'number');
+  });
+
+  it('should have IP_HDRINCL defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IP_HDRINCL, 'number');
+  });
+
+  it('should have IP_TOS defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IP_TOS, 'number');
+  });
+
+  it('should have SO_BROADCAST defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.SO_BROADCAST, 'number');
+  });
+
+  it('should have SO_RCVBUF defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.SO_RCVBUF, 'number');
+  });
+
+  it('should have SO_SNDBUF defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.SO_SNDBUF, 'number');
+  });
+
+  it('should have IPV6_TTL defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IPV6_TTL, 'number');
+  });
+
+  it('should have IPV6_UNICAST_HOPS defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IPV6_UNICAST_HOPS, 'number');
+  });
+
+  it('should have IPV6_V6ONLY defined', () => {
+    // assert
+    assert.strictEqual(typeof SocketOption.IPV6_V6ONLY, 'number');
+  });
+});