node-osc 11.1.1 → 11.2.1

package/dist/test/test-promises.js

@@ -0,0 +1,272 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var util = require('./util.js');
+var nodeOsc = require('node-osc');
+
+tap.beforeEach(util.bootstrap);
+
+tap.test('client: send with promise - array', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(['/test', 0, 1, 'testing', true]);
+  await client.close();
+});
+
+tap.test('client: array is not mutated when sent with promise', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(2);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(originalArray);
+  
+  // Verify the original array was not mutated
+  t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  
+  await client.close();
+});
+
+tap.test('client: send with promise - string', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+
+  await client.send('/test');
+  await client.close();
+});
+
+tap.test('client: send with promise - message object', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 3, 'lol', false], 'we received the payload');
+  });
+
+  await client.send({
+    address: '/test',
+    args: [1, 2, 3, 'lol', false]
+  });
+  await client.close();
+});
+
+tap.test('client: send with promise - multiple args', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 'testing'], 'We should receive expected payload');
+  });
+
+  await client.send('/test', 1, 2, 'testing');
+  await client.close();
+});
+
+tap.test('client: send promise rejection on closed socket', async (t) => {
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  await client.close();
+  
+  try {
+    await client.send('/boom');
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'ERR_SOCKET_DGRAM_NOT_RUNNING', 'Should reject with correct error code');
+  }
+});
+
+tap.test('client: async/await usage', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  const messagePromise = node_events.once(oscServer, 'message');
+
+  await client.send('/async-test', 42, 'hello');
+  const [receivedMessage] = await messagePromise;
+  
+  t.same(receivedMessage, ['/async-test', 42, 'hello'], 'Message received via async/await');
+
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('server: close with promise', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+
+  await oscServer.close();
+  t.pass('Server closed successfully with promise');
+});
+
+tap.test('server: no callback still emits listening event', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+  t.pass('listening event emitted');
+
+  await oscServer.close();
+});
+
+tap.test('client and server: full async/await workflow', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(2);
+
+  // Wait for server to be ready
+  await node_events.once(oscServer, 'listening');
+  t.pass('Server started');
+
+  // Set up message handler
+  const messageReceived = node_events.once(oscServer, 'message');
+
+  // Send message and wait for it to be received
+  await client.send('/workflow', 'test', 123);
+  const [msg] = await messageReceived;
+  t.same(msg, ['/workflow', 'test', 123], 'Message received correctly');
+
+  // Clean up
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('client: multiple sends with promises', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(3);
+
+  const messages = [];
+  oscServer.on('message', (msg) => {
+    messages.push(msg);
+  });
+
+  await client.send('/msg1', 1);
+  await client.send('/msg2', 2);
+  await client.send('/msg3', 3);
+
+  // Give a little time for all messages to be received
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  t.equal(messages.length, 3, 'Received all three messages');
+  t.same(messages[0], ['/msg1', 1], 'First message correct');
+  t.same(messages[2], ['/msg3', 3], 'Last message correct');
+
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('client: close promise rejection on error', async (t) => {
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  // Mock the socket's close method to simulate an error
+  const originalClose = client._sock.close.bind(client._sock);
+  
+  // Set up teardown to ensure socket is properly closed
+  t.teardown(() => {
+    // Restore original close method first
+    client._sock.close = originalClose;
+    // Then close the socket
+    try {
+      client._sock.close(() => {});
+    } catch {
+      // Socket might already be closed, that's ok
+    }
+  });
+  
+  client._sock.close = function(cb) {
+    // Simulate an error being passed to callback
+    if (cb) {
+      const err = new Error('Mock close error');
+      err.code = 'MOCK_ERROR';
+      setImmediate(() => cb(err));
+    }
+  };
+
+  try {
+    await client.close();
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'MOCK_ERROR', 'Should reject with mock error');
+  }
+});
+
+tap.test('server: close promise rejection on error', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+
+  // Mock the socket's close method to simulate an error
+  const originalClose = oscServer._sock.close.bind(oscServer._sock);
+  
+  // Set up teardown to ensure socket is properly closed
+  t.teardown(() => {
+    // Restore original close method first
+    oscServer._sock.close = originalClose;
+    // Then close the socket
+    try {
+      oscServer._sock.close(() => {});
+    } catch {
+      // Socket might already be closed, that's ok
+    }
+  });
+  
+  oscServer._sock.close = function(cb) {
+    // Simulate an error being passed to callback
+    if (cb) {
+      const err = new Error('Mock close error');
+      err.code = 'MOCK_ERROR';
+      setImmediate(() => cb(err));
+    }
+  };
+
+  try {
+    await oscServer.close();
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'MOCK_ERROR', 'Should reject with mock error');
+  }
+});

package/dist/test/test-types.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var tap = require('tap');
+var node_child_process = require('node:child_process');
+var node_path = require('node:path');
+var node_url = require('node:url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const __dirname$1 = node_url.fileURLToPath(new URL('.', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('test-types.js', document.baseURI).href))));
+
+// Only run in ESM mode (not when transpiled to CJS in dist/)
+// Normalize path separators for cross-platform compatibility
+const normalizedPath = __dirname$1.replace(/\\/g, '/');
+const isESM = !normalizedPath.includes('/dist/');
+
+tap.test('types: TypeScript compilation', (t) => {
+  let tsconfigPath;
+  const testRoot = node_path.resolve(__dirname$1, isESM ? '.': '../../test');
+  if (isESM) {
+    tsconfigPath = node_path.join(testRoot, 'fixtures', 'types', 'tsconfig-esm.test.json');
+  }
+  else {
+    tsconfigPath = node_path.join(testRoot, 'fixtures', 'types', 'tsconfig-cjs.test.json');
+  }
+  
+  try {
+    // Run TypeScript compiler
+    const cmd = 'npx tsc --project "' + tsconfigPath + '"';
+    node_child_process.execSync(cmd, { 
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      cwd: node_path.join(testRoot, 'fixtures', 'types')
+    });
+    t.pass('TypeScript types compile successfully');
+  } catch (error) {
+    t.fail('TypeScript compilation failed: ' + error.message);
+    if (error.stdout) console.log('STDOUT:', error.stdout);
+    if (error.stderr) console.log('STDERR:', error.stderr);
+  }
+
+  t.end();
+});

package/dist/test/util.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var node_net = require('node:net');
+var promises = require('node:timers/promises');
 
 async function bootstrap(t) {
   const port = await getPort();
@@ -9,18 +10,24 @@ async function bootstrap(t) {
   };
 }
 
-function getPort() {
-  return new Promise((resolve, reject) => {
-    const server = node_net.createServer();
-    server.unref();
+async function getPort() {
+  const server = node_net.createServer();
+  server.unref();
+  
+  const port = await new Promise((resolve, reject) => {
     server.on('error', reject);
     server.listen(() => {
-      const { port } = server.address();
-      server.close(() => {
-        resolve(port);
-      });
+      resolve(server.address().port);
     });
   });
+  
+  await server.close();
+  
+  // Allow the event loop to process and ensure port is fully released
+  // This prevents EACCES errors when immediately rebinding to the same port
+  await promises.setImmediate();
+  
+  return port;
 }
 
 exports.bootstrap = bootstrap;