@stoprocent/noble 1.19.0 → 2.0.0

package/test/lib/resolve-bindings.test.js

@@ -1,102 +1,227 @@
-const should = require('should');
-const proxyquire = require('proxyquire').noCallThru();
+// Import EventEmitter to extend mock classes
 const { EventEmitter } = require('events');
 
-let chosenPlatform;
-let chosenRelease;
-const platform = () => chosenPlatform;
-const release = () => chosenRelease;
-
-class NobleMac {}
-
-class NobleWinrt {}
-
-const NobleMacImport = proxyquire('../../lib/mac/bindings', {
-  'node-gyp-build': () => ({ NobleMac })
-});
-
-const NobleWinrtImport = proxyquire('../../lib/win/bindings', {
-  'node-gyp-build': () => ({ NobleWinrt })
-});
-
-const WebSocket = require('../../lib/websocket/bindings');
-const NobleBindings = proxyquire('../../lib/distributed/bindings', {
-  ws: { Server: EventEmitter }
-});
-const HciNobleBindings = proxyquire('../../lib/hci-socket/bindings', {
-  './hci': EventEmitter
-});
-const resolver = proxyquire('../../lib/resolve-bindings', {
-  './distributed/bindings': NobleBindings,
-  './hci-socket/bindings': HciNobleBindings,
-  './mac/bindings': NobleMacImport,
-  './win/bindings': NobleWinrtImport,
-  os: { platform, release }
-});
+// Mock classes
+class MockNoble extends EventEmitter {}
+class MockHciBindings extends EventEmitter {}
+class MockMacBindings extends EventEmitter {}
+class MockWinBindings extends EventEmitter {}
+class MockNobleClass {
+  constructor(bindings) {
+    this.bindings = bindings;
+  }
+}
+
+// Mock platform data
+let mockPlatform;
+let mockRelease;
+
+// Mock os module
+jest.mock('os', () => ({
+  platform: () => mockPlatform,
+  release: () => mockRelease
+}));
+
+// Mock the various binding modules
+jest.mock('../../lib/hci-socket/bindings', () => MockHciBindings, { virtual: true });
+jest.mock('../../lib/mac/bindings', () => MockMacBindings, { virtual: true });
+jest.mock('../../lib/win/bindings', () => MockWinBindings, { virtual: true });
+jest.mock('../../lib/noble', () => MockNobleClass, { virtual: true });
+
+// Mock node-gyp-build
+jest.mock('node-gyp-build', () => () => ({
+  NobleMac: MockMacBindings,
+  NobleWinrt: MockWinBindings
+}), { virtual: true });
+
+// Import the module under test after mocks are set up
+let resolver;
 
 describe('resolve-bindings', () => {
   const OLD_ENV = process.env;
 
   beforeEach(() => {
+    // Reset modules before each test to ensure fresh mocks
+    jest.resetModules();
+    
     // Clone initial environment
-    process.env = Object.assign({}, OLD_ENV);
+    process.env = { ...OLD_ENV };
+    
+    // Import the module under test after mocks are set up
+    resolver = require('../../lib/resolve-bindings');
   });
 
   afterEach(() => {
     // Restore initial environment
     process.env = OLD_ENV;
+    
+    // Clear all mocks
+    jest.clearAllMocks();
   });
 
-  it('web socket', () => {
-    process.env.NOBLE_WEBSOCKET = true;
-
-    const bindings = resolver({});
-    should(bindings).instanceof(WebSocket);
-  });
-
-  it('distributed', () => {
-    process.env.NOBLE_DISTRIBUTED = true;
-
-    const bindings = resolver({});
-    should(bindings).instanceof(NobleBindings);
+  describe('default bindings', () => {
+    test('should use Mac bindings on macOS', () => {
+      mockPlatform = 'darwin';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockMacBindings);
+    });
+
+    test('should use HCI bindings on Linux', () => {
+      mockPlatform = 'linux';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should use HCI bindings on FreeBSD', () => {
+      mockPlatform = 'freebsd';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should use Windows bindings on Windows 10 with BLE support', () => {
+      mockPlatform = 'win32';
+      mockRelease = '10.0.15063';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockWinBindings);
+    });
+
+    test('should use HCI bindings on older Windows versions', () => {
+      mockPlatform = 'win32';
+      mockRelease = '6.3.9600'; // Windows 8.1
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should throw error for unsupported platforms', () => {
+      expect(() => resolver('unknown')).toThrow('Unsupported binding type: unknown');
+    });
+
+    test('should use HCI bindings when BLUETOOTH_HCI_SOCKET_UART_PORT is set, regardless of platform', () => {
+      mockPlatform = 'darwin'; // Even on macOS
+      process.env.BLUETOOTH_HCI_SOCKET_UART_PORT = '/dev/ttyUSB0';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should use HCI bindings when BLUETOOTH_HCI_SOCKET_FORCE_UART is set', () => {
+      mockPlatform = 'darwin';
+      process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART = 'true';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should use HCI bindings when USB VID and PID are set', () => {
+      mockPlatform = 'darwin'; // Even on macOS
+      process.env.BLUETOOTH_HCI_SOCKET_USB_VID = '0x0483';
+      process.env.BLUETOOTH_HCI_SOCKET_USB_PID = '0x5740';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should pass options to bindings', () => {
+      mockPlatform = 'darwin';
+      const options = { testOption: true };
+      
+      const noble = resolver('default', options);
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockMacBindings);
+      // Would need to enhance mock to verify options are passed through
+    });
   });
 
-  it('mac', () => {
-    chosenPlatform = 'darwin';
-
-    const bindings = resolver({});
-    should(bindings).instanceof(NobleMac);
-  });
-
-  it('linux', () => {
-    chosenPlatform = 'linux';
-
-    const bindings = resolver({});
-    should(bindings).instanceof(HciNobleBindings);
+  describe('explicit bindings', () => {
+    test('should load HCI bindings when explicitly specified', () => {
+      const noble = resolver('hci');
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should load Mac bindings when explicitly specified', () => {
+      const noble = resolver('mac');
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockMacBindings);
+    });
+
+    test('should load Windows bindings when explicitly specified', () => {
+      mockRelease = '10.0.15063';
+      const noble = resolver('win');
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockWinBindings);
+    });
+
+    test('should throw error for unsupported binding type', () => {
+      expect(() => resolver('unsupported')).toThrow('Unsupported binding type: unsupported');
+    });
+
+    test('should pass options to explicitly specified bindings', () => {
+      const options = { testOption: true };
+      
+      const noble = resolver('hci', options);
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+      // Would need to enhance mock to verify options are passed through
+    });
   });
 
-  it('freebsd', () => {
-    chosenPlatform = 'freebsd';
-
-    const bindings = resolver({});
-    should(bindings).instanceof(HciNobleBindings);
-  });
-
-  it('win32', () => {
-    chosenPlatform = 'win32';
-    chosenRelease = '10.0.22000';
-
-    const bindings = resolver({});
-    should(bindings).instanceof(NobleWinrt);
-  });
-
-  it('unknwon', () => {
-    chosenPlatform = 'unknwon';
-
-    try {
-      resolver({});
-    } catch (e) {
-      should(e).have.property('message', 'Unsupported platform');
-    }
+  describe('Windows version detection', () => {
+    beforeEach(() => {
+      mockPlatform = 'win32';
+    });
+
+    test('should use WinRT bindings on Windows 10 with minimum required version', () => {
+      mockRelease = '10.0.15063'; // Exactly the minimum version
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockWinBindings);
+    });
+
+    test('should use WinRT bindings on Windows 10 with higher version', () => {
+      mockRelease = '10.0.19042'; // Later Windows 10 version
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockWinBindings);
+    });
+
+    test('should use WinRT bindings on Windows 11', () => {
+      mockRelease = '11.0.22621';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockWinBindings);
+    });
+
+    test('should use HCI bindings on Windows 10 with earlier version', () => {
+      mockRelease = '10.0.10240'; // Early Windows 10 without proper BLE support
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
+
+    test('should use HCI bindings on Windows 8.1', () => {
+      mockRelease = '6.3.9600';
+      
+      const noble = resolver();
+      expect(noble).toBeInstanceOf(MockNobleClass);
+      expect(noble.bindings).toBeInstanceOf(MockHciBindings);
+    });
   });
-});
+});

package/test/lib/service.test.js

@@ -1,8 +1,3 @@
-const should = require('should');
-const sinon = require('sinon');
-
-const { assert } = sinon;
-
 const Service = require('../../lib/service');
 
 describe('service', () => {
@@ -13,183 +8,179 @@ describe('service', () => {
   let service = null;
 
   beforeEach(() => {
-    mockNoble = {};
+    mockNoble = {
+      discoverIncludedServices: jest.fn(),
+      discoverCharacteristics: jest.fn(),
+      _withDisconnectHandler: (id, operation) => {
+        return operation();
+      }
+    };
 
     service = new Service(mockNoble, mockPeripheralId, mockUuid);
   });
 
-  it('should have a uuid', () => {
-    should(service.uuid).equal(mockUuid);
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should lookup name and type by uuid', () => {
+  test('should have a uuid', () => {
+    expect(service.uuid).toEqual(mockUuid);
+  });
+
+  test('should lookup name and type by uuid', () => {
     service = new Service(mockNoble, mockPeripheralId, '1800');
 
-    should(service.name).equal('Generic Access');
-    should(service.type).equal('org.bluetooth.service.generic_access');
+    expect(service.name).toEqual('Generic Access');
+    expect(service.type).toEqual('org.bluetooth.service.generic_access');
   });
 
   describe('toString', () => {
-    it('should be uuid, name, type, includedServiceUuids', () => {
-      should(service.toString()).equal('{"uuid":"mock-uuid","name":null,"type":null,"includedServiceUuids":null}');
+    test('should be uuid, name, type, includedServiceUuids', () => {
+      expect(service.toString()).toEqual('{"uuid":"mock-uuid","name":null,"type":null,"includedServiceUuids":null}');
     });
   });
 
   describe('discoverIncludedServices', () => {
-    beforeEach(() => {
-      mockNoble.discoverIncludedServices = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       service.discoverIncludedServices();
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, with uuids', () => {
+    test('should delegate to noble, with uuids', () => {
       const mockUuids = [];
       service.discoverIncludedServices(mockUuids);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       service.discoverIncludedServices(null, callback);
       service.emit('includedServicesDiscover');
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, null);
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, null);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with data', () => {
+    test('should callback with data', () => {
       const mockIncludedServiceUuids = ['service1'];
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       service.discoverIncludedServices(null, callback);
       service.emit('includedServicesDiscover', mockIncludedServiceUuids);
 
-      assert.calledOnceWithExactly(callback, null, mockIncludedServiceUuids);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, null);
+      expect(callback).toHaveBeenCalledWith(undefined, mockIncludedServiceUuids);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, null);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverIncludedServicesAsync', () => {
-    beforeEach(() => {
-      mockNoble.discoverIncludedServices = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = service.discoverIncludedServicesAsync();
       service.emit('includedServicesDiscover');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, with uuids', async () => {
+    test('should delegate to noble, with uuids', async () => {
       const mockUuids = [];
       const promise = service.discoverIncludedServicesAsync(mockUuids);
       service.emit('includedServicesDiscover');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, mockUuids);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve with data', async () => {
+    test('should resolve with data', async () => {
       const mockIncludedServiceUuids = ['service1'];
 
       const promise = service.discoverIncludedServicesAsync();
       service.emit('includedServicesDiscover', mockIncludedServiceUuids);
 
-      should(promise).resolvedWith(mockIncludedServiceUuids);
-      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+      await expect(promise).resolves.toEqual(mockIncludedServiceUuids);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverIncludedServices).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverCharacteristics', () => {
-    beforeEach(() => {
-      mockNoble.discoverCharacteristics = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       service.discoverCharacteristics();
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, with uuids', () => {
+    test('should delegate to noble, with uuids', () => {
       const mockUuids = [];
       service.discoverCharacteristics(mockUuids);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       service.discoverCharacteristics(null, callback);
       service.emit('characteristicsDiscover');
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, null);
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, null);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with data', () => {
+    test('should callback with data', () => {
       const mockCharacteristics = [];
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       service.discoverCharacteristics(null, callback);
       service.emit('characteristicsDiscover', mockCharacteristics);
 
-      assert.calledOnceWithExactly(callback, null, mockCharacteristics);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, null);
+      expect(callback).toHaveBeenCalledWith(undefined, mockCharacteristics);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, null);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverCharacteristicsAsync', () => {
-    beforeEach(() => {
-      mockNoble.discoverCharacteristics = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = service.discoverCharacteristicsAsync();
       service.emit('characteristicsDiscover');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, with uuids', async () => {
+    test('should delegate to noble, with uuids', async () => {
       const mockUuids = [];
       const promise = service.discoverCharacteristicsAsync(mockUuids);
       service.emit('characteristicsDiscover');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, mockUuids);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, mockUuids);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve with data', async () => {
+    test('should resolve with data', async () => {
       const mockCharacteristics = [];
 
       const promise = service.discoverCharacteristicsAsync();
       service.emit('characteristicsDiscover', mockCharacteristics);
 
-      should(promise).resolvedWith(mockCharacteristics);
-      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+      await expect(promise).resolves.toEqual(mockCharacteristics);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledWith(mockPeripheralId, mockUuid, undefined);
+      expect(mockNoble.discoverCharacteristics).toHaveBeenCalledTimes(1);
     });
   });
-});
+});