@stoprocent/noble 1.19.0 → 2.0.0

package/test/lib/hci-socket/bindings.test.js

@@ -1,61 +1,122 @@
-const proxyquire = require('proxyquire').noCallThru();
 const should = require('should');
-const sinon = require('sinon');
-const { assert, fake } = sinon;
 
-describe('hci-socket bindings', () => {
-  const AclStream = sinon.stub();
-  const Gap = sinon.stub();
-
-  const gattOnSpy = sinon.spy();
-  const gattExchangeMtuSpy = sinon.spy();
-  const Gatt = sinon.stub();
-  Gatt.prototype.on = gattOnSpy;
-  Gatt.prototype.exchangeMtu = gattExchangeMtuSpy;
-
-  const createLeConnSpy = sinon.spy();
-  const Hci = sinon.stub();
-  Hci.prototype.createLeConn = createLeConnSpy;
-  Hci.STATUS_MAPPER = { 1: 'custom mapper' };
-
-  const signalingOnSpy = sinon.spy();
-
-  const Signaling = sinon.stub();
-  Signaling.prototype.on = signalingOnSpy;
-
-  const Bindings = proxyquire('../../../lib/hci-socket/bindings', {
-    './acl-stream': AclStream,
-    './gap': Gap,
-    './gatt': Gatt,
-    './hci': Hci,
-    './signaling': Signaling
-  });
+// Mock the required modules before importing the Bindings module
+jest.mock('../../../lib/hci-socket/acl-stream', () => {
+  return jest.fn();
+});
+
+jest.mock('../../../lib/hci-socket/gap', () => {
+  const gapMock = jest.fn();
+  gapMock.prototype.on = jest.fn();
+  gapMock.prototype.setScanParameters = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.startScanning = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.stopScanning = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.setAddress = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.createLeConn = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.disconnect = jest.fn().mockResolvedValue(null);
+  gapMock.prototype.reset = jest.fn().mockResolvedValue(null);
+  return gapMock;
+});
+
+jest.mock('../../../lib/hci-socket/gatt', () => {
+  const gattOnMock = jest.fn();
+  const gattExchangeMtuMock = jest.fn();
+  
+  const gattMock = jest.fn().mockImplementation(() => ({
+    on: gattOnMock,
+    exchangeMtu: gattExchangeMtuMock
+  }));
+  
+  // Make the mocks accessible for assertions
+  gattMock.onMock = gattOnMock;
+  gattMock.exchangeMtuMock = gattExchangeMtuMock;
+  
+  return gattMock;
+});
+
+jest.mock('../../../lib/hci-socket/hci', () => {
+  const createLeConnSpy = jest.fn();
+  
+  const hciMock = jest.fn();
+  hciMock.prototype.createLeConn = createLeConnSpy;
+  hciMock.prototype.on = jest.fn();
+  hciMock.prototype.init = jest.fn();
+  hciMock.prototype.setAddress = jest.fn().mockResolvedValue(null);
+  hciMock.prototype.reset = jest.fn().mockResolvedValue(null);
+  
+  // Add STATUS_MAPPER to the constructor
+  hciMock.STATUS_MAPPER = { 1: 'custom mapper' };
+  
+  // Make createLeConn accessible for later assertions
+  hciMock.createLeConnSpy = createLeConnSpy;
+  
+  return hciMock;
+});
+
+jest.mock('../../../lib/hci-socket/signaling', () => {
+  const signalingOnMock = jest.fn();
+  
+  const signalingMock = jest.fn().mockImplementation(() => ({
+    on: signalingOnMock
+  }));
+  
+  // Make the mock accessible for assertions
+  signalingMock.onMock = signalingOnMock;
+  
+  return signalingMock;
+});
+
+// Mock 'os' module
+jest.mock('os', () => ({
+  platform: jest.fn().mockReturnValue('linux')
+}));
+
+// Import the Bindings module after mocking
+const Bindings = require('../../../lib/hci-socket/bindings');
+const Gap = require('../../../lib/hci-socket/gap');
+const Gatt = require('../../../lib/hci-socket/gatt');
+const Hci = require('../../../lib/hci-socket/hci');
+const AclStream = require('../../../lib/hci-socket/acl-stream');
+const Signaling = require('../../../lib/hci-socket/signaling');
 
+describe('hci-socket bindings', () => {
   let bindings;
-  let clock;
   const options = {};
-
+  
   beforeEach(() => {
-    sinon.stub(process, 'on');
-    sinon.stub(process, 'exit');
-
+    // Mock process methods
+    jest.spyOn(process, 'on').mockImplementation(() => {});
+    jest.spyOn(process, 'exit').mockImplementation(() => {});
+    
+    // Mock console.warn - silent implementation
+    jest.spyOn(console, 'warn').mockImplementation(() => {});
+    
+    // Reset all mock state
+    jest.clearAllMocks();
+    
+    // Mock timing functions
+    jest.useFakeTimers();
+    
+    // Create bindings instance and start it
     bindings = new Bindings(options);
-    clock = sinon.useFakeTimers();
+    bindings.start();
   });
 
   afterEach(() => {
-    process.on.restore();
-    process.exit.restore();
-    clock.restore();
-    sinon.reset();
+    jest.useRealTimers();
+    jest.restoreAllMocks(); // This will restore both process and console.warn mocks
   });
 
   it('constructor', () => {
     should(bindings._state).eql(null);
+    should(bindings._isScanning).eql(false);
+    should(bindings._isScanningStarted).eql(false);
 
     should(bindings._addresses).deepEqual({});
     should(bindings._addresseTypes).deepEqual({});
     should(bindings._connectable).deepEqual({});
+    should(bindings._isExtended).eql('extended' in options && options.extended);
+    should(bindings.scannable).deepEqual({});
 
     should(bindings._pendingConnectionUuid).eql(null);
     should(bindings._connectionQueue).deepEqual([]);
@@ -65,14 +126,14 @@ describe('hci-socket bindings', () => {
     should(bindings._aclStreams).deepEqual({});
     should(bindings._signalings).deepEqual({});
 
-    should(bindings._hci).instanceOf(Hci);
-    should(bindings._gap).instanceOf(Gap);
+  });
 
-    assert.calledOnce(Hci);
-    assert.calledWith(Hci, options);
+  it('start', () => {
+    expect(bindings._gap.on).toHaveBeenCalledTimes(4);
+    expect(bindings._hci.on).toHaveBeenCalledTimes(8);
+    expect(bindings._hci.init).toHaveBeenCalledTimes(1);
 
-    assert.calledOnce(Gap);
-    assert.calledWith(Gap, bindings._hci);
+    expect(process.on).toHaveBeenCalledTimes(2);
   });
 
   describe('onSigInt', () => {
@@ -80,60 +141,96 @@ describe('hci-socket bindings', () => {
       const sigIntListeners = process.listeners('SIGINT');
       bindings._sigIntHandler = sigIntListeners[sigIntListeners.length - 1];
       bindings.onSigInt();
-      assert.calledOnceWithExactly(process.exit, 1);
+      expect(process.exit).toHaveBeenCalledWith(1);
+      expect(process.exit).toHaveBeenCalledTimes(1);
     });
 
     it('should not exit', () => {
-      bindings._sigIntHandler = sinon.spy();
+      bindings._sigIntHandler = jest.fn();
       bindings.onSigInt();
-      assert.notCalled(process.exit);
+      expect(process.exit).not.toHaveBeenCalled();
     });
   });
 
   it('setScanParameters', () => {
-    bindings._gap.setScanParameters = fake.resolves(null);
-
     bindings.setScanParameters('interval', 'window');
 
-    assert.calledOnce(bindings._gap.setScanParameters);
-    assert.calledWith(bindings._gap.setScanParameters, 'interval', 'window');
+    expect(bindings._gap.setScanParameters).toHaveBeenCalledTimes(1);
+    expect(bindings._gap.setScanParameters).toHaveBeenCalledWith('interval', 'window');
   });
 
   describe('startScanning', () => {
-    it('no args', () => {
-      bindings._gap.startScanning = fake.resolves(null);
+    it('no args, already scanning', () => {
+      bindings._isScanning = true;
+      const scanStartSpy = jest.fn();
+      bindings.on('scanStart', scanStartSpy);
 
       bindings.startScanning();
 
       should(bindings._scanServiceUuids).deepEqual([]);
+      expect(scanStartSpy).toHaveBeenCalledTimes(1);
+      expect(bindings._gap.startScanning).not.toHaveBeenCalled();
+    });
+
+    it('no args, not scanning but started', () => {
+      bindings._isScanning = false;
+      bindings._isScanningStarted = true;
+      bindings._gap.startScanning = jest.fn();
 
-      assert.calledOnce(bindings._gap.startScanning);
-      assert.calledWith(bindings._gap.startScanning, undefined);
+      bindings.startScanning();
+
+      should(bindings._scanServiceUuids).deepEqual([]);
+      expect(bindings._gap.startScanning).not.toHaveBeenCalled();
     });
 
-    it('with args', () => {
-      bindings._gap.startScanning = fake.resolves(null);
+    it('with args, first time', () => {
+      bindings._isScanning = false;
+      bindings._isScanningStarted = false;
+      bindings._gap.startScanning = jest.fn();
 
       bindings.startScanning(['uuid'], true);
 
       should(bindings._scanServiceUuids).deepEqual(['uuid']);
+      should(bindings._isScanningStarted).true();
 
-      assert.calledOnce(bindings._gap.startScanning);
-      assert.calledWith(bindings._gap.startScanning, true);
+      expect(bindings._gap.startScanning).toHaveBeenCalledTimes(1);
+      expect(bindings._gap.startScanning).toHaveBeenCalledWith(true);
     });
   });
 
-  it('stopScanning', () => {
-    bindings._gap.stopScanning = fake.resolves(null);
+  describe('stopScanning', () => {
+    it('when scanning', () => {
+      bindings._isScanning = true;
+      bindings._gap.stopScanning = jest.fn();
+
+      bindings.stopScanning();
+
+      expect(bindings._gap.stopScanning).toHaveBeenCalledTimes(1);
+    });
+
+    it('when not scanning', () => {
+      bindings._isScanning = false;
+      bindings._gap.stopScanning = jest.fn();
+      const scanStopSpy = jest.fn();
+      bindings.on('scanStop', scanStopSpy);
+
+      bindings.stopScanning();
+
+      expect(bindings._gap.stopScanning).not.toHaveBeenCalled();
+      expect(scanStopSpy).toHaveBeenCalledTimes(1);
+    });
+  });
 
-    bindings.stopScanning();
+  it('setAddress', () => {
+    bindings.setAddress('test-address');
 
-    assert.calledOnce(bindings._gap.stopScanning);
+    expect(bindings._hci.setAddress).toHaveBeenCalledTimes(1);
+    expect(bindings._hci.setAddress).toHaveBeenCalledWith('test-address');
   });
 
   describe('connect', () => {
     it('missing peripheral, no queue, public address', () => {
-      bindings._hci.createLeConn = fake.resolves(null);
+      bindings._hci.createLeConn = jest.fn();
 
       bindings.connect('112233445566', { addressType: 'public' });
 
@@ -141,12 +238,12 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].id).eql('112233445566');
       should(bindings._connectionQueue[0].params).eql({ addressType: 'public' });
 
-      assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, '11:22:33:44:55:66', 'public', { addressType: 'public' });
+      expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('11:22:33:44:55:66', 'public', { addressType: 'public' });
     });
 
     it('missing peripheral, no queue, random address', () => {
-      bindings._hci.createLeConn = fake.resolves(null);
+      bindings._hci.createLeConn = jest.fn();
 
       bindings.connect('f32233445566', { addressType: 'random' });
 
@@ -154,12 +251,12 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].id).eql('f32233445566');
       should(bindings._connectionQueue[0].params).eql({ addressType: 'random' });
 
-      assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, 'f3:22:33:44:55:66', 'random', { addressType: 'random' });
+      expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('f3:22:33:44:55:66', 'random', { addressType: 'random' });
     });
 
     it('existing peripheral, no queue', () => {
-      bindings._hci.createLeConn = fake.resolves(null);
+      bindings._hci.createLeConn = jest.fn();
       bindings._addresses = {
         peripheralUuid: 'address'
       };
@@ -173,8 +270,8 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].id).eql('peripheralUuid');
       should(bindings._connectionQueue[0].params).eql('parameters');
 
-      assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, 'address', 'addressType', 'parameters');
+      expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('address', 'addressType', 'parameters');
     });
 
     it('missing peripheral, with queue', () => {
@@ -190,24 +287,24 @@ describe('hci-socket bindings', () => {
 
   describe('disconnect', () => {
     it('missing handle', () => {
-      bindings._hci.disconnect = fake.resolves(null);
+      bindings._hci.disconnect = jest.fn();
 
       bindings.disconnect('peripheralUuid');
 
-      assert.calledOnce(bindings._hci.disconnect);
-      assert.calledWith(bindings._hci.disconnect, undefined);
+      expect(bindings._hci.disconnect).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.disconnect).toHaveBeenCalledWith(undefined);
     });
 
     it('existing handle', () => {
       bindings._handles = {
         peripheralUuid: 'handle'
       };
-      bindings._hci.disconnect = fake.resolves(null);
+      bindings._hci.disconnect = jest.fn();
 
       bindings.disconnect('peripheralUuid');
 
-      assert.calledOnce(bindings._hci.disconnect);
-      assert.calledWith(bindings._hci.disconnect, 'handle');
+      expect(bindings._hci.disconnect).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.disconnect).toHaveBeenCalledWith('handle');
     });
   });
 
@@ -215,14 +312,14 @@ describe('hci-socket bindings', () => {
     it('missing handle', () => {
       bindings._connectionQueue.push({ id: 'anotherPeripheralUuid' });
 
-      bindings._hci.cancelConnect = fake.resolves(null);
+      bindings._hci.cancelConnect = jest.fn();
 
       bindings.cancelConnect('peripheralUuid');
 
       should(bindings._connectionQueue).size(1);
 
-      assert.calledOnce(bindings._hci.cancelConnect);
-      assert.calledWith(bindings._hci.cancelConnect, undefined);
+      expect(bindings._hci.cancelConnect).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.cancelConnect).toHaveBeenCalledWith(undefined);
     });
 
     it('existing handle', () => {
@@ -231,188 +328,177 @@ describe('hci-socket bindings', () => {
       };
       bindings._connectionQueue.push({ id: 'anotherPeripheralUuid' });
       bindings._connectionQueue.push({ id: 'peripheralUuid' });
-      bindings._hci.cancelConnect = fake.resolves(null);
+      bindings._hci.cancelConnect = jest.fn();
 
       bindings.cancelConnect('peripheralUuid');
 
       should(bindings._connectionQueue).size(1);
 
-      assert.calledOnce(bindings._hci.cancelConnect);
-      assert.calledWith(bindings._hci.cancelConnect, 'handle');
+      expect(bindings._hci.cancelConnect).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.cancelConnect).toHaveBeenCalledWith('handle');
     });
   });
 
-  it('reset', () => {
-    bindings._hci.reset = fake.resolves(null);
-
-    bindings.reset();
-
-    assert.calledOnce(bindings._hci.reset);
-  });
-
   describe('updateRssi', () => {
     it('missing handle', () => {
-      bindings._hci.readRssi = fake.resolves(null);
+      bindings._hci.readRssi = jest.fn();
 
       bindings.updateRssi('peripheralUuid');
 
-      assert.calledOnce(bindings._hci.readRssi);
-      assert.calledWith(bindings._hci.readRssi, undefined);
+      expect(bindings._hci.readRssi).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.readRssi).toHaveBeenCalledWith(undefined);
     });
 
     it('existing handle', () => {
       bindings._handles = {
         peripheralUuid: 'handle'
       };
-      bindings._hci.readRssi = fake.resolves(null);
+      bindings._hci.readRssi = jest.fn();
 
       bindings.updateRssi('peripheralUuid');
 
-      assert.calledOnce(bindings._hci.readRssi);
-      assert.calledWith(bindings._hci.readRssi, 'handle');
+      expect(bindings._hci.readRssi).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.readRssi).toHaveBeenCalledWith('handle');
     });
   });
 
-  it('init', () => {
-    bindings._gap.on = fake.resolves(null);
-    bindings._hci.on = fake.resolves(null);
-    bindings._hci.init = fake.resolves(null);
-
-    bindings.init();
-
-    assert.callCount(bindings._gap.on, 4);
-    assert.callCount(bindings._hci.on, 8);
-    assert.calledOnce(bindings._hci.init);
-
-    assert.calledTwice(process.on);
-  });
-
   describe('stop', () => {
     it('no handles', () => {
-      bindings._gap.stopScanning = fake.resolves(null);
-      bindings._hci.reset = fake.resolves(null);
-      bindings._hci.stop = fake.resolves(null);
-      bindings._sigIntHandler = fake.resolves(null);
-      bindings._exitHandler = fake.resolves(null);
+      bindings._isScanning = true;
+      bindings._gap.stopScanning = jest.fn();
+      bindings._hci.reset = jest.fn();
+      bindings._hci.stop = jest.fn();
+      bindings._sigIntHandler = jest.fn();
+      bindings._exitHandler = jest.fn();
       
       bindings.stop();
-
-      assert.calledOnce(bindings._gap.stopScanning);
-      assert.calledOnce(bindings._hci.reset);
-      assert.calledOnce(bindings._hci.stop);
+      
+      expect(bindings._gap.stopScanning).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.reset).not.toHaveBeenCalled();  // Reset is not called in stop()
+      expect(bindings._hci.stop).toHaveBeenCalledTimes(1);
     });
 
     it('with handles', () => {
-      bindings._gap.stopScanning = fake.resolves(null);
-      bindings._hci.disconnect = fake.resolves(null);
-      bindings._hci.reset = fake.resolves(null);
-      bindings._hci.stop = fake.resolves(null);
-      bindings._sigIntHandler = fake.resolves(null);
-      bindings._exitHandler = fake.resolves(null);
+      bindings._isScanning = true;
+      bindings._gap.stopScanning = jest.fn();
+      bindings._hci.disconnect = jest.fn();
+      bindings._hci.reset = jest.fn();
+      bindings._hci.stop = jest.fn();
+      bindings._sigIntHandler = jest.fn();
+      bindings._exitHandler = jest.fn();
 
       bindings._aclStreams = [1, 2, 3];
 
       bindings.stop();
 
-      assert.calledOnce(bindings._gap.stopScanning);
-      assert.calledThrice(bindings._hci.disconnect);
+      expect(bindings._gap.stopScanning).toHaveBeenCalledTimes(1);
+      expect(bindings._hci.disconnect).toHaveBeenCalledTimes(3);
     });
   });
 
   describe('onStateChange', () => {
     it('same state', () => {
-      const stateChange = fake.resolves(null);
+      const stateChange = jest.fn();
 
       bindings._state = 'state';
       bindings.on('stateChange', stateChange);
 
       bindings.onStateChange('state');
 
-      assert.notCalled(stateChange);
+      expect(stateChange).not.toHaveBeenCalled();
     });
 
     it('new state', () => {
-      const stateChange = fake.resolves(null);
+      const stateChange = jest.fn();
 
       bindings._state = 'state';
       bindings.on('stateChange', stateChange);
 
       bindings.onStateChange('newState');
 
-      assert.calledOnce(stateChange);
-      assert.calledWith(stateChange, 'newState');
+      expect(stateChange).toHaveBeenCalledTimes(1);
+      expect(stateChange).toHaveBeenCalledWith('newState');
     });
 
     it('unauthorized', () => {
-      const stateChange = fake.resolves(null);
+      const stateChange = jest.fn();
 
       bindings._state = 'state';
       bindings.on('stateChange', stateChange);
+      
+      jest.spyOn(console, 'log').mockImplementation(() => {});
 
       bindings.onStateChange('unauthorized');
 
-      assert.calledOnce(stateChange);
-      assert.calledWith(stateChange, 'unauthorized');
+      expect(stateChange).toHaveBeenCalledTimes(1);
+      expect(stateChange).toHaveBeenCalledWith('unauthorized');
+
+      expect(console.log).toHaveBeenCalledTimes(3);
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('adapter state unauthorized'));
     });
 
     it('unsupported', () => {
-      const stateChange = fake.resolves(null);
+      const stateChange = jest.fn();
 
       bindings._state = 'state';
       bindings.on('stateChange', stateChange);
 
+      jest.spyOn(console, 'log').mockImplementation(() => {});
+
       bindings.onStateChange('unsupported');
 
-      assert.calledOnce(stateChange);
-      assert.calledWith(stateChange, 'unsupported');
+      expect(stateChange).toHaveBeenCalledTimes(1);
+      expect(stateChange).toHaveBeenCalledWith('unsupported');
+      expect(console.log).toHaveBeenCalledTimes(3);
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('adapter does not support Bluetooth'));
     });
   });
 
   it('onAddressChange', () => {
-    const onAddressChange = fake.resolves(null);
+    const onAddressChange = jest.fn();
 
     bindings.on('addressChange', onAddressChange);
 
     bindings.onAddressChange('newAddress');
 
-    assert.calledOnce(onAddressChange);
-    assert.calledWith(onAddressChange, 'newAddress');
+    expect(onAddressChange).toHaveBeenCalledTimes(1);
+    expect(onAddressChange).toHaveBeenCalledWith('newAddress');
   });
 
   it('onScanParametersSet', () => {
-    const onScanParametersSet = fake.resolves(null);
+    const onScanParametersSet = jest.fn();
 
     bindings.on('scanParametersSet', onScanParametersSet);
 
     bindings.onScanParametersSet();
 
-    assert.calledOnce(onScanParametersSet);
+    expect(onScanParametersSet).toHaveBeenCalledTimes(1);
   });
 
   it('onScanStart', () => {
-    const onScanStart = fake.resolves(null);
+    const onScanStart = jest.fn();
 
     bindings.on('scanStart', onScanStart);
 
     bindings.onScanStart('filterDuplicates');
 
-    assert.calledOnce(onScanStart);
-    assert.calledWith(onScanStart, 'filterDuplicates');
+    expect(onScanStart).toHaveBeenCalledTimes(1);
+    expect(onScanStart).toHaveBeenCalledWith('filterDuplicates');
   });
 
   it('onScanStop', () => {
-    const onScanStop = fake.resolves(null);
+    const onScanStop = jest.fn();
 
     bindings.on('scanStop', onScanStop);
 
     bindings.onScanStop();
 
-    assert.calledOnce(onScanStop);
+    expect(onScanStop).toHaveBeenCalledTimes(1);
   });
 
   describe('onDiscover', () => {
     it('new device, no scanServiceUuids', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -424,19 +510,19 @@ describe('hci-socket bindings', () => {
       const connectable = 'connectable';
       const advertisement = 'advertisement';
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       const uuid = 'addressasmac';
       should(bindings._addresses).deepEqual({ [uuid]: address });
       should(bindings._addresseTypes).deepEqual({ [uuid]: addressType });
       should(bindings._connectable).deepEqual({ [uuid]: connectable });
 
-      assert.calledOnce(onDiscover);
-      assert.calledWith(onDiscover, uuid, address, addressType, connectable, advertisement, rssi);
+      expect(onDiscover).toHaveBeenCalledTimes(1);
+      expect(onDiscover).toHaveBeenCalledWith(uuid, address, addressType, connectable, advertisement, rssi, undefined);
     });
 
     it('new device, with matching scanServiceUuids', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -450,19 +536,19 @@ describe('hci-socket bindings', () => {
         serviceUuids: ['service-uuid']
       };
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       const uuid = 'addressasmac';
       should(bindings._addresses).deepEqual({ [uuid]: address });
       should(bindings._addresseTypes).deepEqual({ [uuid]: addressType });
       should(bindings._connectable).deepEqual({ [uuid]: connectable });
 
-      assert.calledOnce(onDiscover);
-      assert.calledWith(onDiscover, uuid, address, addressType, connectable, advertisement, rssi);
+      expect(onDiscover).toHaveBeenCalledTimes(1);
+      expect(onDiscover).toHaveBeenCalledWith(uuid, address, addressType, connectable, advertisement, rssi, undefined);
     });
 
     it('new device, with non-matching scanServiceUuids', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -476,17 +562,17 @@ describe('hci-socket bindings', () => {
         serviceUuids: ['another-service-uuid']
       };
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       should(bindings._addresses).deepEqual({});
       should(bindings._addresseTypes).deepEqual({});
       should(bindings._connectable).deepEqual({});
 
-      assert.notCalled(onDiscover);
+      expect(onDiscover).not.toHaveBeenCalled();
     });
 
     it('new device, with service data on advertisement', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -500,19 +586,19 @@ describe('hci-socket bindings', () => {
         serviceData: [{ uuid: 'service-uuid' }]
       };
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       const uuid = 'addressasmac';
       should(bindings._addresses).deepEqual({ [uuid]: address });
       should(bindings._addresseTypes).deepEqual({ [uuid]: addressType });
       should(bindings._connectable).deepEqual({ [uuid]: connectable });
 
-      assert.calledOnce(onDiscover);
-      assert.calledWith(onDiscover, uuid, address, addressType, connectable, advertisement, rssi);
+      expect(onDiscover).toHaveBeenCalledTimes(1);
+      expect(onDiscover).toHaveBeenCalledWith(uuid, address, addressType, connectable, advertisement, rssi, undefined);
     });
 
     it('new device, non matching service data on advertisement', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -526,17 +612,17 @@ describe('hci-socket bindings', () => {
         serviceData: [{ uuid: 'another-service-uuid' }]
       };
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       should(bindings._addresses).deepEqual({});
       should(bindings._addresseTypes).deepEqual({});
       should(bindings._connectable).deepEqual({});
 
-      assert.notCalled(onDiscover);
+      expect(onDiscover).not.toHaveBeenCalled();
     });
 
     it('new device, no services on advertisement', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -548,17 +634,17 @@ describe('hci-socket bindings', () => {
       const connectable = 'connectable';
       const advertisement = {};
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       should(bindings._addresses).deepEqual({});
       should(bindings._addresseTypes).deepEqual({});
       should(bindings._connectable).deepEqual({});
 
-      assert.notCalled(onDiscover);
+      expect(onDiscover).not.toHaveBeenCalled();
     });
 
     it('new device, undefined _scanServiceUuids', () => {
-      const onDiscover = fake.resolves(null);
+      const onDiscover = jest.fn();
 
       bindings.on('discover', onDiscover);
 
@@ -572,13 +658,13 @@ describe('hci-socket bindings', () => {
         serviceData: [{ uuid: 'service-uuid' }]
       };
       const rssi = 'rssi';
-      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi);
+      bindings.onDiscover(status, address, addressType, connectable, advertisement, rssi, undefined);
 
       should(bindings._addresses).deepEqual({});
       should(bindings._addresseTypes).deepEqual({});
       should(bindings._connectable).deepEqual({});
 
-      assert.notCalled(onDiscover);
+      expect(onDiscover).not.toHaveBeenCalled();
     });
   });
 
@@ -590,12 +676,12 @@ describe('hci-socket bindings', () => {
       const addressType = 'addressType';
       const address = 'address';
 
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
-      assert.notCalled(connectCallback);
+      expect(connectCallback).not.toHaveBeenCalled();
     });
 
     it('with right status on master node', () => {
@@ -605,41 +691,42 @@ describe('hci-socket bindings', () => {
       const addressType = 'addressType';
       const address = 'address:split:by:separator';
 
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
-      clock.tick(0);
-
-      assert.calledOnce(AclStream);
-      assert.calledOnce(Gatt);
-      assert.calledOnce(Signaling);
-
-      assert.callCount(gattOnSpy, 17);
-      assert.calledWithMatch(gattOnSpy, 'mtu', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'servicesDiscover', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'servicesDiscovered', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'includedServicesDiscover', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'characteristicsDiscover', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'characteristicsDiscovered', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'read', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'write', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'broadcast', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'notify', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'notification', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'descriptorsDiscover', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'valueRead', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'valueWrite', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'handleRead', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'handleWrite', sinon.match.func);
-      assert.calledWithMatch(gattOnSpy, 'handleNotify', sinon.match.func);
-
-      assert.calledOnceWithMatch(signalingOnSpy, 'connectionParameterUpdateRequest', sinon.match.func);
-
-      assert.calledOnceWithExactly(gattExchangeMtuSpy);
-
-      assert.calledOnceWithExactly(connectCallback, 'addresssplitbyseparator', null);
+      jest.advanceTimersByTime(0);
+
+      expect(AclStream).toHaveBeenCalledTimes(1);
+      expect(Gatt).toHaveBeenCalledTimes(1);
+      expect(Signaling).toHaveBeenCalledTimes(1);
+
+      expect(Gatt.onMock).toHaveBeenCalledTimes(17);
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+      expect(Gatt.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+
+      expect(Signaling.onMock).toHaveBeenCalledTimes(1);
+      expect(Signaling.onMock).toHaveBeenCalledWith(expect.any(String), expect.any(Function));
+
+      expect(Gatt.exchangeMtuMock).toHaveBeenCalledTimes(1);
+
+      expect(connectCallback).toHaveBeenCalledTimes(1);
+      expect(connectCallback).toHaveBeenCalledWith('addresssplitbyseparator', null);
 
       should(bindings._pendingConnectionUuid).equal(null);
     });
@@ -651,17 +738,20 @@ describe('hci-socket bindings', () => {
       const addressType = 'addressType';
       const address = 'address:split:by:separator';
 
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       bindings._connectionQueue.push({ id: 'pending_uuid' });
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
-      assert.notCalled(AclStream);
-      assert.notCalled(Gatt);
-      assert.notCalled(Signaling);
+      expect(AclStream).not.toHaveBeenCalled();
+      expect(Gatt).not.toHaveBeenCalled();
+      expect(Signaling).not.toHaveBeenCalled();
 
-      assert.calledOnceWithMatch(connectCallback, 'pending_uuid', sinon.match({ message: 'custom mapper (0x1)' }));
+      expect(connectCallback).toHaveBeenCalledTimes(1);
+      expect(connectCallback).toHaveBeenCalledWith('pending_uuid', expect.objectContaining({ 
+        message: 'custom mapper (0x1)' 
+      }));
 
       should(bindings._connectionQueue).length(0);
     });
@@ -673,17 +763,20 @@ describe('hci-socket bindings', () => {
       const addressType = 'addressType';
       const address = 'address:split:by:separator';
 
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       bindings._connectionQueue.push({ id: 'pending_uuid' });
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
-      assert.notCalled(AclStream);
-      assert.notCalled(Gatt);
-      assert.notCalled(Signaling);
+      expect(AclStream).not.toHaveBeenCalled();
+      expect(Gatt).not.toHaveBeenCalled();
+      expect(Signaling).not.toHaveBeenCalled();
 
-      assert.calledOnceWithExactly(connectCallback, 'pending_uuid', sinon.match({ message: 'HCI Error: Unknown (0x2)' }));
+      expect(connectCallback).toHaveBeenCalledTimes(1);
+      expect(connectCallback).toHaveBeenCalledWith('pending_uuid', expect.objectContaining({ 
+        message: 'HCI Error: Unknown (0x2)' 
+      }));
 
       should(bindings._connectionQueue).length(0);
     });
@@ -695,7 +788,7 @@ describe('hci-socket bindings', () => {
       const addressType = 'random';
       const address = '11:22:33:44:55:66';
 
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       bindings._addresses = { 'queuedId_1': '112233445566', 'queuedId_2': '998877665544' };
       bindings._addresseTypes = { 'queuedId_1': 'random', 'queuedId_2': 'public' };
@@ -705,26 +798,92 @@ describe('hci-socket bindings', () => {
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
-      assert.calledOnceWithExactly(connectCallback, '112233445566', null);
-      assert.calledWithExactly(createLeConnSpy, '112233445566', 'random', { addressType: 'random' });
-      assert.calledWithExactly(createLeConnSpy, '998877665544', 'public', { addressType: 'public' });
+      expect(connectCallback).toHaveBeenCalledTimes(1);
+      expect(connectCallback).toHaveBeenCalledWith('112233445566', null);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(2);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
 
       should(bindings._connectionQueue).length(1);
     });
+
+    it('with longer connection queue', () => {
+      const status = 0;
+      const handle = 'handle';
+      const role = 0;
+      const addressType = 'random';
+      const address = '11:22:33:44:55:66';
+
+      const connectCallback = jest.fn();
+
+      bindings._addresses = { 'queuedId_1': '112233445566', 'queuedId_2': '998877665544', 'queuedId_3': 'aabbccddeeff' };
+      bindings._addresseTypes = { 'queuedId_1': 'random', 'queuedId_2': 'public', 'queuedId_3': 'random' };
+      bindings.connect('queuedId_1', { addressType: 'random' });
+      bindings.connect('queuedId_2', { addressType: 'public' });
+      bindings.connect('queuedId_3', { addressType: 'random' });
+
+      bindings.on('connect', connectCallback);
+      bindings.onLeConnComplete(status, handle, role, addressType, address);
+
+      expect(connectCallback).toHaveBeenCalledTimes(1);
+      expect(connectCallback).toHaveBeenCalledWith('112233445566', null);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(2);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
+      expect(bindings._connectionQueue).toHaveLength(2);
+    });
+
+    it('with longer connection queue where 2 connections are completed', () => {
+      const status = 0;
+      const handle = 'handle';
+      const role = 0;
+      const addressType = 'random';
+      const address = '11:22:33:44:55:66';
+
+      const status2 = 0;
+      const handle2 = 'handle2';
+      const role2 = 0;
+      const addressType2 = 'public';
+      const address2 = '99:88:77:66:55:44';
+
+      const connectCallback = jest.fn();
+
+      bindings._addresses = { 'queuedId_1': '112233445566', 'queuedId_2': '998877665544', 'queuedId_3': 'aabbccddeeff' };
+      bindings._addresseTypes = { 'queuedId_1': 'random', 'queuedId_2': 'public', 'queuedId_3': 'random' };
+      bindings.connect('queuedId_1', { addressType: 'random' });
+      bindings.connect('queuedId_2', { addressType: 'public' });
+      bindings.connect('queuedId_3', { addressType: 'random' });
+
+      bindings.on('connect', connectCallback);
+
+      bindings.onLeConnComplete(status, handle, role, addressType, address);
+      bindings.onLeConnComplete(status2, handle2, role2, addressType2, address2);
+
+      expect(connectCallback).toHaveBeenCalledTimes(2);
+      
+      expect(connectCallback).toHaveBeenCalledWith('112233445566', null);
+      expect(connectCallback).toHaveBeenCalledWith('998877665544', null);
+
+      expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(3);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('aabbccddeeff', 'random', { addressType: 'random' });
+      expect(bindings._connectionQueue).toHaveLength(1);
+    });
   });
 
   describe('onDisconnComplete', () => {
     it('handle not found', () => {
-      const disconnectCallback = sinon.spy();
+      const disconnectCallback = jest.fn();
 
       bindings.on('disconnect', disconnectCallback);
       bindings.onDisconnComplete('missing', 'reason');
 
-      assert.notCalled(disconnectCallback);
+      expect(disconnectCallback).not.toHaveBeenCalled();
     });
 
     it('existing handle', () => {
-      const disconnectCallback = sinon.spy();
+      const disconnectCallback = jest.fn();
       const handle = 'handle';
       const anotherHandle = 'another_handle';
       const uuid = 'uuid';
@@ -732,10 +891,10 @@ describe('hci-socket bindings', () => {
       const reason = 'reason';
 
       const gattSpy = {
-        removeAllListeners: sinon.spy()
+        removeAllListeners: jest.fn()
       };
       const signalingSpy = {
-        removeAllListeners: sinon.spy()
+        removeAllListeners: jest.fn()
       };
 
       // Init expected
@@ -757,9 +916,10 @@ describe('hci-socket bindings', () => {
       bindings.on('disconnect', disconnectCallback);
       bindings.onDisconnComplete(handle, reason);
 
-      assert.calledOnceWithExactly(disconnectCallback, uuid, reason);
-      assert.calledOnceWithExactly(gattSpy.removeAllListeners);
-      assert.calledOnceWithExactly(signalingSpy.removeAllListeners);
+      expect(disconnectCallback).toHaveBeenCalledTimes(1);
+      expect(disconnectCallback).toHaveBeenCalledWith(uuid, reason);
+      expect(gattSpy.removeAllListeners).toHaveBeenCalledTimes(1);
+      expect(signalingSpy.removeAllListeners).toHaveBeenCalledTimes(1);
 
       should(bindings._handles).not.have.keys(uuid, handle);
       should(bindings._aclStreams).not.have.keys(handle);
@@ -774,62 +934,66 @@ describe('hci-socket bindings', () => {
       const anotherHandle = 'another_handle';
       const encrypt = 'encrypt';
       const aclSpy = {
-        pushEncrypt: sinon.spy()
+        pushEncrypt: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onEncryptChange(anotherHandle, encrypt);
 
-      assert.notCalled(aclSpy.pushEncrypt);
+      expect(aclSpy.pushEncrypt).not.toHaveBeenCalled();
     });
 
     it('existing handle', () => {
       const handle = 'handle';
       const encrypt = 'encrypt';
       const aclSpy = {
-        pushEncrypt: sinon.spy()
+        pushEncrypt: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onEncryptChange(handle, encrypt);
 
-      assert.calledOnceWithExactly(aclSpy.pushEncrypt, encrypt);
+      expect(aclSpy.pushEncrypt).toHaveBeenCalledTimes(1);
+      expect(aclSpy.pushEncrypt).toHaveBeenCalledWith(encrypt);
     });
 
     it('existing handle no encrypt', () => {
       const handle = 'handle';
       const aclSpy = {
-        pushEncrypt: sinon.spy()
+        pushEncrypt: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onEncryptChange(handle);
 
-      assert.calledOnceWithExactly(aclSpy.pushEncrypt, undefined);
+      expect(aclSpy.pushEncrypt).toHaveBeenCalledTimes(1);
+      expect(aclSpy.pushEncrypt).toHaveBeenCalledWith(undefined);
     });
   });
 
   it('onMtu', () => {
     const address = 'this:is:an:address';
     const rssi = 'rssi';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('onMtu', callback);
     bindings.onMtu(address, rssi);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', rssi);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', rssi);
   });
 
   it('onRssiRead', () => {
     const handle = 'handle';
     const rssi = 'rssi';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings._handles[handle] = 'binding_handle';
     bindings.on('rssiUpdate', callback);
     bindings.onRssiRead(handle, rssi);
 
-    assert.calledOnceWithExactly(callback, 'binding_handle', rssi);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('binding_handle', rssi);
   });
 
   describe('onAclDataPkt', () => {
@@ -839,13 +1003,13 @@ describe('hci-socket bindings', () => {
       const cid = 'cid';
       const data = 'data';
       const aclSpy = {
-        push: sinon.spy()
+        push: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onAclDataPkt(anotherHandle, cid, data);
 
-      assert.notCalled(aclSpy.push);
+      expect(aclSpy.push).not.toHaveBeenCalled();
     });
 
     it('existing handle', () => {
@@ -853,25 +1017,27 @@ describe('hci-socket bindings', () => {
       const cid = 'cid';
       const data = 'data';
       const aclSpy = {
-        push: sinon.spy()
+        push: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onAclDataPkt(handle, cid, data);
 
-      assert.calledOnceWithExactly(aclSpy.push, cid, data);
+      expect(aclSpy.push).toHaveBeenCalledTimes(1);
+      expect(aclSpy.push).toHaveBeenCalledWith(cid, data);
     });
 
     it('existing handle no cid no data', () => {
       const handle = 'handle';
       const aclSpy = {
-        push: sinon.spy()
+        push: jest.fn()
       };
 
       bindings._aclStreams[handle] = aclSpy;
       bindings.onAclDataPkt(handle);
 
-      assert.calledOnceWithExactly(aclSpy.push, undefined, undefined);
+      expect(aclSpy.push).toHaveBeenCalledTimes(1);
+      expect(aclSpy.push).toHaveBeenCalledWith(undefined, undefined);
     });
   });
 
@@ -882,14 +1048,14 @@ describe('hci-socket bindings', () => {
       const anotherHandle = 'another_handle';
       const service = 'service';
       const gatt = {
-        addService: sinon.spy()
+        addService: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.addService(peripheralUuid, service);
 
-      assert.notCalled(gatt.addService);
+      expect(gatt.addService).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -897,28 +1063,30 @@ describe('hci-socket bindings', () => {
       const handle = 'handle';
       const service = 'service';
       const gatt = {
-        addService: sinon.spy()
+        addService: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.addService(peripheralUuid, service);
 
-      assert.calledOnceWithExactly(gatt.addService, service);
+      expect(gatt.addService).toHaveBeenCalledTimes(1);
+      expect(gatt.addService).toHaveBeenCalledWith(service);
     });
 
     it('existing gatt no service', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        addService: sinon.spy()
+        addService: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.addService(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.addService, undefined);
+      expect(gatt.addService).toHaveBeenCalledTimes(1);
+      expect(gatt.addService).toHaveBeenCalledWith(undefined);
     });
   });
 
@@ -929,14 +1097,14 @@ describe('hci-socket bindings', () => {
       const anotherHandle = 'another_handle';
       const uuids = 'uuids';
       const gatt = {
-        discoverServices: sinon.spy()
+        discoverServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.discoverServices(peripheralUuid, uuids);
 
-      assert.notCalled(gatt.discoverServices);
+      expect(gatt.discoverServices).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -944,51 +1112,55 @@ describe('hci-socket bindings', () => {
       const handle = 'handle';
       const uuids = 'uuids';
       const gatt = {
-        discoverServices: sinon.spy()
+        discoverServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverServices(peripheralUuid, uuids);
 
-      assert.calledOnceWithExactly(gatt.discoverServices, uuids);
+      expect(gatt.discoverServices).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverServices).toHaveBeenCalledWith(uuids);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        discoverServices: sinon.spy()
+        discoverServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverServices(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.discoverServices, []);
+      expect(gatt.discoverServices).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverServices).toHaveBeenCalledWith([]);
     });
   });
 
   it('onServicesDiscovered', () => {
     const address = 'this:is:an:address';
     const serviceUuids = 'serviceUuids';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('servicesDiscover', callback);
     bindings.onServicesDiscovered(address, serviceUuids);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuids);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuids);
   });
 
   it('onServicesDiscoveredEX', () => {
     const address = 'this:is:an:address';
     const serviceUuids = 'serviceUuids';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('servicesDiscovered', callback);
     bindings.onServicesDiscoveredEX(address, serviceUuids);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuids);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuids);
   });
 
   describe('discoverIncludedServices', () => {
@@ -999,14 +1171,14 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'service-uuid';
       const serviceUuids = 'serviceUuids';
       const gatt = {
-        discoverIncludedServices: sinon.spy()
+        discoverIncludedServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.discoverIncludedServices(peripheralUuid, serviceUuid, serviceUuids);
 
-      assert.notCalled(gatt.discoverIncludedServices);
+      expect(gatt.discoverIncludedServices).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1015,14 +1187,15 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'service-uuid';
       const serviceUuids = 'serviceUuids';
       const gatt = {
-        discoverIncludedServices: sinon.spy()
+        discoverIncludedServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverIncludedServices(peripheralUuid, serviceUuid, serviceUuids);
 
-      assert.calledOnceWithExactly(gatt.discoverIncludedServices, serviceUuid, serviceUuids);
+      expect(gatt.discoverIncludedServices).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverIncludedServices).toHaveBeenCalledWith(serviceUuid, serviceUuids);
     });
 
     it('existing gatt no uuids', () => {
@@ -1030,14 +1203,15 @@ describe('hci-socket bindings', () => {
       const handle = 'handle';
       const serviceUuid = 'service-uuid';
       const gatt = {
-        discoverIncludedServices: sinon.spy()
+        discoverIncludedServices: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverIncludedServices(peripheralUuid, serviceUuid);
 
-      assert.calledOnceWithExactly(gatt.discoverIncludedServices, serviceUuid, []);
+      expect(gatt.discoverIncludedServices).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverIncludedServices).toHaveBeenCalledWith(serviceUuid, []);
     });
   });
 
@@ -1045,12 +1219,13 @@ describe('hci-socket bindings', () => {
     const address = 'this:is:an:address';
     const serviceUuid = 'serviceUuid';
     const includedServiceUuids = 'includedServiceUuids';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('includedServicesDiscover', callback);
     bindings.onIncludedServicesDiscovered(address, serviceUuid, includedServiceUuids);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, includedServiceUuids);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, includedServiceUuids);
   });
 
   describe('addCharacteristics', () => {
@@ -1061,14 +1236,14 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristics = 'characteristics';
       const gatt = {
-        addCharacteristics: sinon.spy()
+        addCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.addCharacteristics(peripheralUuid, serviceUuid, characteristics);
 
-      assert.notCalled(gatt.addCharacteristics);
+      expect(gatt.addCharacteristics).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1077,28 +1252,30 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristics = 'characteristics';
       const gatt = {
-        addCharacteristics: sinon.spy()
+        addCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.addCharacteristics(peripheralUuid, serviceUuid, characteristics);
 
-      assert.calledOnceWithExactly(gatt.addCharacteristics, serviceUuid, characteristics);
+      expect(gatt.addCharacteristics).toHaveBeenCalledTimes(1);
+      expect(gatt.addCharacteristics).toHaveBeenCalledWith(serviceUuid, characteristics);
     });
 
     it('existing gatt no serviceUuid no characteristics', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        addCharacteristics: sinon.spy()
+        addCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.addCharacteristics(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.addCharacteristics, undefined, undefined);
+      expect(gatt.addCharacteristics).toHaveBeenCalledTimes(1);
+      expect(gatt.addCharacteristics).toHaveBeenCalledWith(undefined, undefined);
     });
   });
 
@@ -1110,14 +1287,14 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuids = 'characteristics';
       const gatt = {
-        discoverCharacteristics: sinon.spy()
+        discoverCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.discoverCharacteristics(peripheralUuid, serviceUuid, characteristicUuids);
 
-      assert.notCalled(gatt.discoverCharacteristics);
+      expect(gatt.discoverCharacteristics).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1126,14 +1303,15 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuids = 'characteristics';
       const gatt = {
-        discoverCharacteristics: sinon.spy()
+        discoverCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverCharacteristics(peripheralUuid, serviceUuid, characteristicUuids);
 
-      assert.calledOnceWithExactly(gatt.discoverCharacteristics, serviceUuid, characteristicUuids);
+      expect(gatt.discoverCharacteristics).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverCharacteristics).toHaveBeenCalledWith(serviceUuid, characteristicUuids);
     });
 
     it('existing gatt no uuids', () => {
@@ -1141,14 +1319,15 @@ describe('hci-socket bindings', () => {
       const handle = 'handle';
       const serviceUuid = 'serviceUuid';
       const gatt = {
-        discoverCharacteristics: sinon.spy()
+        discoverCharacteristics: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverCharacteristics(peripheralUuid, serviceUuid);
 
-      assert.calledOnceWithExactly(gatt.discoverCharacteristics, serviceUuid, []);
+      expect(gatt.discoverCharacteristics).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverCharacteristics).toHaveBeenCalledWith(serviceUuid, []);
     });
   });
 
@@ -1156,24 +1335,26 @@ describe('hci-socket bindings', () => {
     const address = 'this:is:an:address';
     const serviceUuid = 'serviceUuid';
     const characteristics = 'characteristics';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('characteristicsDiscover', callback);
     bindings.onCharacteristicsDiscovered(address, serviceUuid, characteristics);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristics);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristics);
   });
 
   it('onCharacteristicsDiscoveredEX', () => {
     const address = 'this:is:an:address';
     const serviceUuid = 'serviceUuid';
     const characteristics = 'characteristics';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('characteristicsDiscovered', callback);
     bindings.onCharacteristicsDiscoveredEX(address, serviceUuid, characteristics);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristics);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristics);
   });
 
   describe('read', () => {
@@ -1184,14 +1365,14 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuid = 'characteristic';
       const gatt = {
-        read: sinon.spy()
+        read: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.read(peripheralUuid, serviceUuid, characteristicUuid);
 
-      assert.notCalled(gatt.read);
+      expect(gatt.read).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1200,28 +1381,30 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuid = 'characteristics';
       const gatt = {
-        read: sinon.spy()
+        read: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.read(peripheralUuid, serviceUuid, characteristicUuid);
 
-      assert.calledOnceWithExactly(gatt.read, serviceUuid, characteristicUuid);
+      expect(gatt.read).toHaveBeenCalledTimes(1);
+      expect(gatt.read).toHaveBeenCalledWith(serviceUuid, characteristicUuid);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        read: sinon.spy()
+        read: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.read(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.read, undefined, undefined);
+      expect(gatt.read).toHaveBeenCalledTimes(1);
+      expect(gatt.read).toHaveBeenCalledWith(undefined, undefined);
     });
   });
 
@@ -1230,12 +1413,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const data = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('read', callback);
     bindings.onRead(address, serviceUuid, characteristicUuid, data);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, data, false);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, data, false);
   });
 
   describe('write', () => {
@@ -1249,14 +1433,14 @@ describe('hci-socket bindings', () => {
       const withoutResponse = true;
 
       const gatt = {
-        write: sinon.spy()
+        write: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.write(peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse);
 
-      assert.notCalled(gatt.write);
+      expect(gatt.write).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1267,28 +1451,30 @@ describe('hci-socket bindings', () => {
       const data = 'data';
       const withoutResponse = true;
       const gatt = {
-        write: sinon.spy()
+        write: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.write(peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse);
 
-      assert.calledOnceWithExactly(gatt.write, serviceUuid, characteristicUuid, data, withoutResponse);
+      expect(gatt.write).toHaveBeenCalledTimes(1);
+      expect(gatt.write).toHaveBeenCalledWith(serviceUuid, characteristicUuid, data, withoutResponse);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        write: sinon.spy()
+        write: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.write(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.write, undefined, undefined, undefined, undefined);
+      expect(gatt.write).toHaveBeenCalledTimes(1);
+      expect(gatt.write).toHaveBeenCalledWith(undefined, undefined, undefined, undefined);
     });
   });
 
@@ -1296,12 +1482,13 @@ describe('hci-socket bindings', () => {
     const address = 'this:is:an:address';
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('write', callback);
     bindings.onWrite(address, serviceUuid, characteristicUuid);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid);
   });
 
   describe('broadcast', () => {
@@ -1313,14 +1500,14 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristic';
       const broadcast = 'broadcast';
       const gatt = {
-        broadcast: sinon.spy()
+        broadcast: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.broadcast(peripheralUuid, serviceUuid, characteristicUuid, broadcast);
 
-      assert.notCalled(gatt.broadcast);
+      expect(gatt.broadcast).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1330,28 +1517,30 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristics';
       const broadcast = 'broadcast';
       const gatt = {
-        broadcast: sinon.spy()
+        broadcast: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.broadcast(peripheralUuid, serviceUuid, characteristicUuid, broadcast);
 
-      assert.calledOnceWithExactly(gatt.broadcast, serviceUuid, characteristicUuid, broadcast);
+      expect(gatt.broadcast).toHaveBeenCalledTimes(1);
+      expect(gatt.broadcast).toHaveBeenCalledWith(serviceUuid, characteristicUuid, broadcast);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        broadcast: sinon.spy()
+        broadcast: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.broadcast(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.broadcast, undefined, undefined, undefined);
+      expect(gatt.broadcast).toHaveBeenCalledTimes(1);
+      expect(gatt.broadcast).toHaveBeenCalledWith(undefined, undefined, undefined);
     });
   });
 
@@ -1360,12 +1549,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const state = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('broadcast', callback);
     bindings.onBroadcast(address, serviceUuid, characteristicUuid, state);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, state);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, state);
   });
 
   describe('notify', () => {
@@ -1377,14 +1567,14 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristic';
       const notify = 'notify';
       const gatt = {
-        notify: sinon.spy()
+        notify: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.notify(peripheralUuid, serviceUuid, characteristicUuid, notify);
 
-      assert.notCalled(gatt.notify);
+      expect(gatt.notify).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1394,28 +1584,30 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristics';
       const notify = 'notify';
       const gatt = {
-        notify: sinon.spy()
+        notify: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.notify(peripheralUuid, serviceUuid, characteristicUuid, notify);
 
-      assert.calledOnceWithExactly(gatt.notify, serviceUuid, characteristicUuid, notify);
+      expect(gatt.notify).toHaveBeenCalledTimes(1);
+      expect(gatt.notify).toHaveBeenCalledWith(serviceUuid, characteristicUuid, notify);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        notify: sinon.spy()
+        notify: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.notify(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.notify, undefined, undefined, undefined);
+      expect(gatt.notify).toHaveBeenCalledTimes(1);
+      expect(gatt.notify).toHaveBeenCalledWith(undefined, undefined, undefined);
     });
   });
 
@@ -1424,12 +1616,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const state = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('notify', callback);
     bindings.onNotify(address, serviceUuid, characteristicUuid, state);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, state);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, state);
   });
 
   it('onNotification', () => {
@@ -1437,12 +1630,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const data = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('read', callback);
     bindings.onNotification(address, serviceUuid, characteristicUuid, data);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, data, true);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, data, true);
   });
 
   describe('discoverDescriptors', () => {
@@ -1453,14 +1647,14 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuid = 'characteristic';
       const gatt = {
-        discoverDescriptors: sinon.spy()
+        discoverDescriptors: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.discoverDescriptors(peripheralUuid, serviceUuid, characteristicUuid);
 
-      assert.notCalled(gatt.discoverDescriptors);
+      expect(gatt.discoverDescriptors).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1469,28 +1663,30 @@ describe('hci-socket bindings', () => {
       const serviceUuid = 'serviceUuid';
       const characteristicUuid = 'characteristics';
       const gatt = {
-        discoverDescriptors: sinon.spy()
+        discoverDescriptors: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverDescriptors(peripheralUuid, serviceUuid, characteristicUuid);
 
-      assert.calledOnceWithExactly(gatt.discoverDescriptors, serviceUuid, characteristicUuid);
+      expect(gatt.discoverDescriptors).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverDescriptors).toHaveBeenCalledWith(serviceUuid, characteristicUuid);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        discoverDescriptors: sinon.spy()
+        discoverDescriptors: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.discoverDescriptors(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.discoverDescriptors, undefined, undefined);
+      expect(gatt.discoverDescriptors).toHaveBeenCalledTimes(1);
+      expect(gatt.discoverDescriptors).toHaveBeenCalledWith(undefined, undefined);
     });
   });
 
@@ -1499,12 +1695,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const descriptorUuids = 'descriptorUuids';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('descriptorsDiscover', callback);
     bindings.onDescriptorsDiscovered(address, serviceUuid, characteristicUuid, descriptorUuids);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, descriptorUuids);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, descriptorUuids);
   });
 
   describe('readValue', () => {
@@ -1516,14 +1713,14 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristic';
       const descriptorUuid = 'descriptorUuid';
       const gatt = {
-        readValue: sinon.spy()
+        readValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.readValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid);
 
-      assert.notCalled(gatt.readValue);
+      expect(gatt.readValue).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1533,28 +1730,30 @@ describe('hci-socket bindings', () => {
       const characteristicUuid = 'characteristics';
       const descriptorUuid = 'descriptorUuid';
       const gatt = {
-        readValue: sinon.spy()
+        readValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.readValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid);
 
-      assert.calledOnceWithExactly(gatt.readValue, serviceUuid, characteristicUuid, descriptorUuid);
+      expect(gatt.readValue).toHaveBeenCalledTimes(1);
+      expect(gatt.readValue).toHaveBeenCalledWith(serviceUuid, characteristicUuid, descriptorUuid);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        readValue: sinon.spy()
+        readValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.readValue(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.readValue, undefined, undefined, undefined);
+      expect(gatt.readValue).toHaveBeenCalledTimes(1);
+      expect(gatt.readValue).toHaveBeenCalledWith(undefined, undefined, undefined);
     });
   });
 
@@ -1564,12 +1763,13 @@ describe('hci-socket bindings', () => {
     const characteristicUuid = 'characteristics';
     const descriptorUuid = 'descriptorUuid';
     const data = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('valueRead', callback);
     bindings.onValueRead(address, serviceUuid, characteristicUuid, descriptorUuid, data);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, descriptorUuid, data);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, descriptorUuid, data);
   });
 
   describe('writeValue', () => {
@@ -1582,14 +1782,14 @@ describe('hci-socket bindings', () => {
       const descriptorUuid = 'descriptorUuid';
       const data = 'data';
       const gatt = {
-        writeValue: sinon.spy()
+        writeValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.writeValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
 
-      assert.notCalled(gatt.writeValue);
+      expect(gatt.writeValue).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1600,28 +1800,30 @@ describe('hci-socket bindings', () => {
       const descriptorUuid = 'descriptorUuid';
       const data = 'data';
       const gatt = {
-        writeValue: sinon.spy()
+        writeValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.writeValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
 
-      assert.calledOnceWithExactly(gatt.writeValue, serviceUuid, characteristicUuid, descriptorUuid, data);
+      expect(gatt.writeValue).toHaveBeenCalledTimes(1);
+      expect(gatt.writeValue).toHaveBeenCalledWith(serviceUuid, characteristicUuid, descriptorUuid, data);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        writeValue: sinon.spy()
+        writeValue: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.writeValue(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.writeValue, undefined, undefined, undefined, undefined);
+      expect(gatt.writeValue).toHaveBeenCalledTimes(1);
+      expect(gatt.writeValue).toHaveBeenCalledWith(undefined, undefined, undefined, undefined);
     });
   });
 
@@ -1630,12 +1832,13 @@ describe('hci-socket bindings', () => {
     const serviceUuid = 'serviceUuid';
     const characteristicUuid = 'characteristics';
     const descriptorUuid = 'descriptorUuid';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('valueWrite', callback);
     bindings.onValueWrite(address, serviceUuid, characteristicUuid, descriptorUuid);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', serviceUuid, characteristicUuid, descriptorUuid);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', serviceUuid, characteristicUuid, descriptorUuid);
   });
 
   describe('readHandle', () => {
@@ -1645,14 +1848,14 @@ describe('hci-socket bindings', () => {
       const anotherHandle = 'another_handle';
       const attHandle = 'attHandle';
       const gatt = {
-        readHandle: sinon.spy()
+        readHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.readHandle(peripheralUuid, attHandle);
 
-      assert.notCalled(gatt.readHandle);
+      expect(gatt.readHandle).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1660,28 +1863,30 @@ describe('hci-socket bindings', () => {
       const handle = 'handle';
       const attHandle = 'attHandle';
       const gatt = {
-        readHandle: sinon.spy()
+        readHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.readHandle(peripheralUuid, attHandle);
 
-      assert.calledOnceWithExactly(gatt.readHandle, attHandle);
+      expect(gatt.readHandle).toHaveBeenCalledTimes(1);
+      expect(gatt.readHandle).toHaveBeenCalledWith(attHandle);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        readHandle: sinon.spy()
+        readHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.readHandle(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.readHandle, undefined);
+      expect(gatt.readHandle).toHaveBeenCalledTimes(1);
+      expect(gatt.readHandle).toHaveBeenCalledWith(undefined);
     });
   });
 
@@ -1689,12 +1894,13 @@ describe('hci-socket bindings', () => {
     const address = 'this:is:an:address';
     const handle = 'handle';
     const data = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('handleRead', callback);
     bindings.onHandleRead(address, handle, data);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', handle, data);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', handle, data);
   });
 
   describe('writeHandle', () => {
@@ -1706,14 +1912,14 @@ describe('hci-socket bindings', () => {
       const data = 'data';
       const withoutResponse = true;
       const gatt = {
-        writeHandle: sinon.spy()
+        writeHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = anotherHandle;
       bindings._gatts[handle] = gatt;
       bindings.writeHandle(peripheralUuid, attHandle, data, withoutResponse);
 
-      assert.notCalled(gatt.writeHandle);
+      expect(gatt.writeHandle).not.toHaveBeenCalled();
     });
 
     it('existing gatt', () => {
@@ -1723,52 +1929,56 @@ describe('hci-socket bindings', () => {
       const data = 'data';
       const withoutResponse = true;
       const gatt = {
-        writeHandle: sinon.spy()
+        writeHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.writeHandle(peripheralUuid, attHandle, data, withoutResponse);
 
-      assert.calledOnceWithExactly(gatt.writeHandle, attHandle, data, withoutResponse);
+      expect(gatt.writeHandle).toHaveBeenCalledTimes(1);
+      expect(gatt.writeHandle).toHaveBeenCalledWith(attHandle, data, withoutResponse);
     });
 
     it('existing gatt no uuids', () => {
       const peripheralUuid = 'uuid';
       const handle = 'handle';
       const gatt = {
-        writeHandle: sinon.spy()
+        writeHandle: jest.fn()
       };
 
       bindings._handles[peripheralUuid] = handle;
       bindings._gatts[handle] = gatt;
       bindings.writeHandle(peripheralUuid);
 
-      assert.calledOnceWithExactly(gatt.writeHandle, undefined, undefined, undefined);
+      expect(gatt.writeHandle).toHaveBeenCalledTimes(1);
+      expect(gatt.writeHandle).toHaveBeenCalledWith(undefined, undefined, undefined);
     });
   });
 
   it('onHandleWrite', () => {
     const address = 'this:is:an:address';
     const handle = 'handle';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('handleWrite', callback);
     bindings.onHandleWrite(address, handle);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', handle);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', handle);
   });
 
   it('onHandleNotify', () => {
     const address = 'this:is:an:address';
     const handle = 'handle';
     const data = 'data';
-    const callback = sinon.spy();
+    const callback = jest.fn();
 
     bindings.on('handleNotify', callback);
     bindings.onHandleNotify(address, handle, data);
 
-    assert.calledOnceWithExactly(callback, 'thisisanaddress', handle, data);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith('thisisanaddress', handle, data);
   });
 
   it('onConnectionParameterUpdateRequest', () => {
@@ -1777,11 +1987,12 @@ describe('hci-socket bindings', () => {
     const maxInterval = 'maxInterval';
     const latency = 'latency';
     const supervisionTimeout = 'supervisionTimeout';
-    const connUpdateLe = sinon.spy();
+    const connUpdateLe = jest.fn();
 
     bindings._hci.connUpdateLe = connUpdateLe;
     bindings.onConnectionParameterUpdateRequest(handle, minInterval, maxInterval, latency, supervisionTimeout);
 
-    assert.calledOnceWithExactly(connUpdateLe, handle, minInterval, maxInterval, latency, supervisionTimeout);
+    expect(connUpdateLe).toHaveBeenCalledTimes(1);
+    expect(connUpdateLe).toHaveBeenCalledWith(handle, minInterval, maxInterval, latency, supervisionTimeout);
   });
 });