node-osc 11.2.0 → 11.2.2

package/test/test-message.mjs

@@ -1,54 +1,67 @@
-import { beforeEach, test } from 'tap';
-import { bootstrap } from './util.mjs';
-
+import { once } from 'node:events';
+import { test } from 'tap';
 import { Server, Client, Message } from 'node-osc';
 
 function round(num) {
   return Math.round(num * 100) / 100;
 }
 
-beforeEach(bootstrap);
+test('message: basic usage', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
 
-test('message: basic usage', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
   const m = new Message('/address');
   m.append('testing');
   m.append(123);
   m.append([456, 789]);
   
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = ['/address', 'testing', 123, 456, 789];
     t.same(msg, expected, `We reveived the payload: ${msg}`);
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: multiple args', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: multiple args', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+  
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+  
   const m = new Message('/address', 'testing', 123, true);
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = ['/address', 'testing', 123, true];
     t.same(msg, expected, `We reveived the payload: ${msg}`);
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: object', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: object', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
   const m = new Message('/address');
   m.append({
     type: 'string',
@@ -59,43 +72,51 @@ test('message: object', (t) => {
     value: 100
   });
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = ['/address', 'test', 100];
     t.same(msg, expected, `We reveived the payload: ${msg}`);
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: float', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: float', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(2);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
   const m = new Message('/address');
   m.append(3.14);
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = [
       '/address',
       3.14
     ];
     t.equal(msg[0], expected[0], `We reveived the payload: ${msg}`);
     t.equal(round(msg[1]), expected[1], 'pie please');
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: alias messages', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: alias messages', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(5);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
   const m = new Message('/address');
   m.append({
     type: 'i',
@@ -106,7 +127,7 @@ test('message: alias messages', (t) => {
     value: 3.14
   });
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = [
       '/address',
       123,
@@ -117,39 +138,47 @@ test('message: alias messages', (t) => {
     t.ok(Number.isInteger(msg[1]), 'the first value is an int');
     t.equal(round(msg[2]), expected[2], 'pie please');
     t.ok(msg[2] % 1 !== 0, 'the second value is a float');
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: boolean', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: boolean', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const client = new Client('127.0.0.1', server.port);
   const m = new Message('/address');
   m.append(true);
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = [
       '/address',
       true
     ];
     t.same(msg, expected, `We reveived the payload: ${msg}`);
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
-  });
+  client.send(m);
 });
 
-test('message: blob', (t) => {
-  const oscServer = new Server(t.context.port, '127.0.0.1');
-  const client = new Client('127.0.0.1', t.context.port);
+test('message: blob', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
   const m = new Message('/address');
   const buf = Buffer.from('test');
   m.append({
@@ -157,19 +186,42 @@ test('message: blob', (t) => {
     value: buf
   });
 
-  oscServer.on('message', (msg) => {
+  server.on('message', (msg) => {
     const expected = [
       '/address',
       buf
     ];
     t.same(msg, expected, `We reveived the payload: ${msg}`);
-    oscServer.close();
-    t.end();
   });
 
-  client.send(m, () => {
-    client.close();
+  client.send(m);
+});
+
+test('message: Buffer as blob', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
   });
+
+  const m = new Message('/address');
+  const buf = Buffer.from('test buffer data');
+  // Directly append Buffer without wrapping in object
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the buffer payload: ${msg}`);
+  });
+
+  client.send(m);
 });
 
 // test('message: timetag', (t) => {
@@ -191,6 +243,150 @@ test('message: blob', (t) => {
 //   });
 // });
 
+test('message: Buffer with multiple arguments', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(6);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new Message('/address');
+  const buf1 = Buffer.from('first');
+  const buf2 = Buffer.from('second');
+
+  m.append('string');
+  m.append(42);
+  m.append(buf1);
+  m.append(3.14);
+  m.append(buf2);
+
+  server.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.equal(msg[1], 'string', 'String matches');
+    t.equal(msg[2], 42, 'Integer matches');
+    t.same(msg[3], buf1, 'First buffer matches');
+    t.equal(round(msg[4]), 3.14, 'Float matches');
+    t.same(msg[5], buf2, 'Second buffer matches')
+  });
+
+  client.send(m);
+});
+
+test('message: Buffer in constructor', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const buf = Buffer.from('constructor buffer');
+  const m = new Message('/address', 'test', buf, 123);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      'test',
+      buf,
+      123
+    ];
+    t.same(msg, expected, `We received the constructor buffer payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+test('message: Buffer in array', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new Message('/address');
+  const buf1 = Buffer.from('array1');
+  const buf2 = Buffer.from('array2');
+
+  m.append([buf1, 'string', buf2, 456]);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf1,
+      'string',
+      buf2,
+      456
+    ];
+    t.same(msg, expected, `We received the array with buffers: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+test('message: empty Buffer', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new Message('/address');
+  const buf = Buffer.from('');
+  
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the empty buffer: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+test('message: large Buffer', async (t) => {
+  const server = new Server(0, '127.0.0.1');
+  await once(server, 'listening');
+  const client = new Client('127.0.0.1', server.port);
+
+  t.plan(4);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new Message('/address');
+  const buf = Buffer.alloc(1024, 'x');
+  
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.ok(Buffer.isBuffer(msg[1]), 'Second element is a Buffer');
+    t.equal(msg[1].length, 1024, 'Buffer size matches');
+    t.same(msg[1], buf, 'Buffer content matches');
+  });
+
+  client.send(m);
+});
+
 test('message: error', (t) => {
   const m = new Message('/address');
   t.plan(2);

package/test/test-osc-internal.mjs

@@ -23,6 +23,46 @@ test('osc: timetag encoding with non-number value', (t) => {
   t.end();
 });
 
+test('osc: timetag encoding with zero value', (t) => {
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 0,
+    elements: [
+      {
+        oscType: 'message',
+        address: '/test',
+        args: []
+      }
+    ]
+  };
+
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
+
+  t.equal(decoded.timetag, 0, 'should encode 0 as immediate execution');
+  t.end();
+});
+
+test('osc: timetag encoding with numeric epoch value', (t) => {
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 42,
+    elements: [
+      {
+        oscType: 'message',
+        address: '/test',
+        args: []
+      }
+    ]
+  };
+
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
+
+  t.equal(decoded.timetag, 42, 'should preserve numeric timetag values');
+  t.end();
+});
+
 test('osc: timetag with immediate execution values', (t) => {
   // Test readTimeTag with seconds === 0 && fraction === 1
   const bundle = {
@@ -765,6 +805,117 @@ test('osc: explicit double type name', (t) => {
   t.end();
 });
 
+test('osc: malformed packet with missing string terminator', (t) => {
+  const buffer = Buffer.from('/test', 'utf8');
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Missing null terminator for string/, 'should throw on unterminated string');
+  t.end();
+});
+
+test('osc: malformed packet with truncated int32 argument', (t) => {
+  const address = Buffer.from('/i\0\0', 'ascii');
+  const typeTags = Buffer.from(',i\0\0', 'ascii');
+  const truncated = Buffer.from([0x00, 0x01]);
+  const buffer = Buffer.concat([address, typeTags, truncated]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for int32/, 'should throw on truncated int32');
+  t.end();
+});
+
+test('osc: malformed packet with truncated float32 argument', (t) => {
+  const address = Buffer.from('/f\0\0', 'ascii');
+  const typeTags = Buffer.from(',f\0\0', 'ascii');
+  const truncated = Buffer.from([0x3f, 0x80, 0x00]);
+  const buffer = Buffer.concat([address, typeTags, truncated]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for float32/, 'should throw on truncated float32');
+  t.end();
+});
+
+test('osc: malformed packet with invalid blob length', (t) => {
+  const address = Buffer.from('/b\0\0', 'ascii');
+  const typeTags = Buffer.from(',b\0\0', 'ascii');
+  const length = Buffer.alloc(4);
+  length.writeInt32BE(-1, 0);
+  const buffer = Buffer.concat([address, typeTags, length]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Invalid blob length/, 'should throw on negative blob length');
+  t.end();
+});
+
+test('osc: malformed packet with truncated blob data', (t) => {
+  const address = Buffer.from('/b\0\0', 'ascii');
+  const typeTags = Buffer.from(',b\0\0', 'ascii');
+  const length = Buffer.alloc(4);
+  length.writeInt32BE(4, 0);
+  const data = Buffer.from([0x01, 0x02]);
+  const buffer = Buffer.concat([address, typeTags, length, data]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for blob/, 'should throw on truncated blob data');
+  t.end();
+});
+
+test('osc: malformed packet with missing blob padding', (t) => {
+  const address = Buffer.from('/b\0\0', 'ascii');
+  const typeTags = Buffer.from(',b\0\0', 'ascii');
+  const length = Buffer.alloc(4);
+  length.writeInt32BE(3, 0);
+  const data = Buffer.from([0x01, 0x02, 0x03]);
+  const buffer = Buffer.concat([address, typeTags, length, data]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for blob padding/, 'should throw on missing blob padding');
+  t.end();
+});
+
+test('osc: malformed bundle with truncated timetag', (t) => {
+  const bundleHeader = Buffer.from('#bundle\0', 'ascii');
+  const timetag = Buffer.alloc(4);
+  const buffer = Buffer.concat([bundleHeader, timetag]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for timetag/, 'should throw on truncated timetag');
+  t.end();
+});
+
+test('osc: malformed bundle with invalid element size', (t) => {
+  const bundleHeader = Buffer.from('#bundle\0', 'ascii');
+  const timetag = Buffer.alloc(8);
+  const size = Buffer.alloc(4);
+  size.writeInt32BE(0, 0);
+  const buffer = Buffer.concat([bundleHeader, timetag, size]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet/, 'should throw on invalid bundle element size');
+  t.end();
+});
+
+test('osc: malformed bundle with oversized element size', (t) => {
+  const bundleHeader = Buffer.from('#bundle\0', 'ascii');
+  const timetag = Buffer.alloc(8);
+  const size = Buffer.alloc(4);
+  size.writeInt32BE(12, 0);
+  const buffer = Buffer.concat([bundleHeader, timetag, size, Buffer.from([0x01, 0x02])]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet/, 'should throw on oversized bundle element size');
+  t.end();
+});
+
 test('osc: blob padding when length is multiple of 4', (t) => {
   // Test writeBlob line 52: padding === 4 branch (should use 0)
   const message = {