@stoprocent/noble 1.19.0 → 2.0.0

package/test/lib/peripheral.test.js

@@ -1,7 +1,3 @@
-const should = require('should');
-const sinon = require('sinon');
-const { fake, assert } = sinon;
-
 const Peripheral = require('../../lib/peripheral');
 
 describe('peripheral', () => {
@@ -18,287 +14,272 @@ describe('peripheral', () => {
   let peripheral = null;
 
   beforeEach(() => {
-    mockNoble = {};
-    peripheral = new Peripheral(mockNoble, mockId, mockAddress, mockAddressType, mockConnectable, mockAdvertisement, mockRssi);
+    mockNoble = {
+      _withDisconnectHandler: (id, operation) => {
+        return new Promise((resolve, reject) => {
+          return Promise.resolve(operation())
+            .then(result => {
+              resolve(result);
+            })
+            .catch(error => {
+              reject(error);
+            });
+        });
+      },
+      connect: jest.fn(),
+      cancelConnect: jest.fn(),
+      disconnect: jest.fn(),
+      updateRssi: jest.fn(),
+      discoverServices: jest.fn(),
+      readHandle: jest.fn(),
+      writeHandle: jest.fn()
+    };
+    
+    peripheral = new Peripheral(
+      mockNoble, 
+      mockId, 
+      mockAddress, 
+      mockAddressType, 
+      mockConnectable, 
+      mockAdvertisement, 
+      mockRssi
+    );
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should have a id', () => {
-    should(peripheral.id).equal(mockId);
+  test('should have a id', () => {
+    expect(peripheral.id).toEqual(mockId);
   });
 
-  it('should have an address', () => {
-    should(peripheral.address).equal(mockAddress);
+  test('should have an address', () => {
+    expect(peripheral.address).toEqual(mockAddress);
   });
 
-  it('should have an address type', () => {
-    should(peripheral.addressType).equal(mockAddressType);
+  test('should have an address type', () => {
+    expect(peripheral.addressType).toEqual(mockAddressType);
   });
 
-  it('should have connectable', () => {
-    should(peripheral.connectable).equal(mockConnectable);
+  test('should have connectable', () => {
+    expect(peripheral.connectable).toEqual(mockConnectable);
   });
 
-  it('should have advertisement', () => {
-    should(peripheral.advertisement).equal(mockAdvertisement);
+  test('should have advertisement', () => {
+    expect(peripheral.advertisement).toEqual(mockAdvertisement);
   });
 
-  it('should have rssi', () => {
-    should(peripheral.rssi).equal(mockRssi);
+  test('should have rssi', () => {
+    expect(peripheral.rssi).toEqual(mockRssi);
   });
 
   describe('toString', () => {
-    it('should be id, address, address type, connectable, advertisement, rssi, state', () => {
-      should(peripheral.toString()).equal('{"id":"mock-id","address":"mock-address","addressType":"mock-address-type","connectable":"mock-connectable","advertisement":"mock-advertisement","rssi":"mock-rssi","mtu":null,"state":"disconnected"}');
+    test('should be id, address, address type, connectable, advertisement, rssi, state', () => {
+      expect(peripheral.toString()).toEqual(
+        '{"id":"mock-id","address":"mock-address","addressType":"mock-address-type","connectable":"mock-connectable","advertisement":"mock-advertisement","rssi":"mock-rssi","mtu":null,"state":"disconnected"}'
+      );
     });
   });
 
   describe('connect', () => {
-    beforeEach(() => {
-      mockNoble.connect = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       peripheral.connect();
 
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, undefined);
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, undefined);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       peripheral.connect(callback);
       peripheral.emit('connect', 'error');
 
-      assert.calledOnceWithExactly(callback, 'error');
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, undefined);
+      expect(callback).toHaveBeenCalledWith('error');
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, undefined);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
 
-    it('with options, no callback', () => {
+    test('with options, no callback', () => {
       const options = { options: true };
 
       peripheral.connect(options);
       peripheral.emit('connect');
 
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, options);
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, options);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
 
-    it('both options and callback', () => {
+    test('both options and callback', () => {
       const options = { options: true };
-      const callback = fake.returns(null);
+      const callback = jest.fn();
 
       peripheral.connect(options, callback);
       peripheral.emit('connect');
 
-      assert.calledOnceWithExactly(callback, undefined);
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, options);
+      expect(callback).toHaveBeenCalledWith(undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, options);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('connectAsync', () => {
-    beforeEach(() => {
-      mockNoble.connect = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should resolve', async () => {
+    test('should resolve', async () => {
       const promise = peripheral.connectAsync();
       peripheral.emit('connect');
 
-      should(promise).resolvedWith(undefined);
+      await expect(promise).resolves.toBeUndefined();
     });
 
-    it('should reject on error', async () => {
+    test('should reject on error', async () => {
       const promise = peripheral.connectAsync();
       peripheral.emit('connect', new Error('error'));
-
-      should(promise).rejectedWith('error');
+      
+      await expect(promise).rejects.toThrow('error');
     });
 
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = peripheral.connectAsync();
       peripheral.emit('connect');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, undefined);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, undefined);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
 
-    it('with options', async () => {
+    test('with options', async () => {
       const options = { options: true };
 
       const promise = peripheral.connectAsync(options);
       peripheral.emit('connect');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.connect, mockId, options);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.connect).toHaveBeenCalledWith(mockId, options);
+      expect(mockNoble.connect).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('cancelConnect', () => {
-    beforeEach(() => {
-      mockNoble.connect = sinon.spy();
-      mockNoble.cancelConnect = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('not connecting, should resolve', async () => {
+    test('not connecting, should resolve', async () => {
       await peripheral.cancelConnect();
 
-      assert.notCalled(mockNoble.cancelConnect);
+      expect(mockNoble.cancelConnect).not.toHaveBeenCalled();
     });
 
-    it('connecting, should emit connect with error', async () => {
+    test('connecting, should emit connect with error', async () => {
       const options = { options: true };
-      const connectCallback = sinon.spy();
+      const connectCallback = jest.fn();
 
       peripheral.connect(connectCallback);
       peripheral.cancelConnect(options);
 
-      assert.calledOnceWithMatch(connectCallback, sinon.match({ message: 'connection canceled!' }));
-      assert.calledOnceWithExactly(mockNoble.cancelConnect, mockId, options);
+      expect(connectCallback).toHaveBeenCalledWith(expect.objectContaining({
+        message: 'connection canceled!'
+      }));
+      expect(mockNoble.cancelConnect).toHaveBeenCalledWith(mockId, options);
+      expect(mockNoble.cancelConnect).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('disconnect', () => {
-    beforeEach(() => {
-      mockNoble.disconnect = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       peripheral.disconnect();
-      assert.calledOnceWithExactly(mockNoble.disconnect, mockId);
+      expect(mockNoble.disconnect).toHaveBeenCalledWith(mockId);
+      expect(mockNoble.disconnect).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       peripheral.disconnect(callback);
       peripheral.emit('disconnect');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(mockNoble.disconnect, mockId);
+      expect(callback).toHaveBeenCalledWith(null);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.disconnect).toHaveBeenCalledWith(mockId);
+      expect(mockNoble.disconnect).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('disconnectAsync', () => {
-    beforeEach(() => {
-      mockNoble.disconnect = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', async () => {
       const promise = peripheral.disconnectAsync();
       peripheral.emit('disconnect');
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.disconnect, mockId);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.disconnect).toHaveBeenCalledWith(mockId);
+      expect(mockNoble.disconnect).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('updateRssi', () => {
-    beforeEach(() => {
-      mockNoble.updateRssi = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       peripheral.updateRssi();
-      assert.calledOnceWithExactly(mockNoble.updateRssi, mockId);
+      expect(mockNoble.updateRssi).toHaveBeenCalledWith(mockId);
+      expect(mockNoble.updateRssi).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       peripheral.updateRssi(callback);
       peripheral.emit('rssiUpdate', 'new-rssi');
 
-      assert.calledOnceWithExactly(callback, null, 'new-rssi');
-      assert.calledOnceWithExactly(mockNoble.updateRssi, mockId);
+      expect(callback).toHaveBeenCalledWith(undefined, 'new-rssi');
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.updateRssi).toHaveBeenCalledWith(mockId);
+      expect(mockNoble.updateRssi).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('updateRssiAsync', () => {
-    beforeEach(() => {
-      mockNoble.updateRssi = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should resolve with rssi', async () => {
+    test('should resolve with rssi', async () => {
       const promise = peripheral.updateRssiAsync();
       peripheral.emit('rssiUpdate', 'new-rssi');
-      should(promise).resolvedWith('new-rssi');
+      
+      await expect(promise).resolves.toEqual('new-rssi');
     });
   });
 
   describe('discoverServices', () => {
-    beforeEach(() => {
-      mockNoble.discoverServices = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       peripheral.discoverServices();
-      assert.calledOnceWithExactly(mockNoble.discoverServices, mockId, undefined);
+      expect(mockNoble.discoverServices).toHaveBeenCalledWith(mockId, undefined);
+      expect(mockNoble.discoverServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, service uuids', () => {
+    test('should delegate to noble, service uuids', () => {
       const mockServiceUuids = [];
       peripheral.discoverServices(mockServiceUuids);
-      assert.calledOnceWithExactly(mockNoble.discoverServices, mockId, mockServiceUuids);
+      expect(mockNoble.discoverServices).toHaveBeenCalledWith(mockId, mockServiceUuids);
+      expect(mockNoble.discoverServices).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
       peripheral.discoverServices('uuids', callback);
       peripheral.emit('servicesDiscover', 'services');
 
-      assert.alwaysCalledWithExactly(callback, null, 'services');
-      assert.calledOnceWithExactly(mockNoble.discoverServices, mockId, 'uuids');
+      expect(callback).toHaveBeenCalledWith(undefined, 'services');
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverServices).toHaveBeenCalledWith(mockId, 'uuids');
+      expect(mockNoble.discoverServices).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverServicesAsync', () => {
-    beforeEach(() => {
-      mockNoble.discoverServices = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should resolve with services', async () => {
+    test('should resolve with services', async () => {
       const mockServices = 'discoveredServices';
 
       const promise = peripheral.discoverServicesAsync('uuids');
       peripheral.emit('servicesDiscover', mockServices);
 
-      should(promise).resolvedWith(mockServices);
-      assert.calledOnceWithExactly(mockNoble.discoverServices, mockId, 'uuids');
+      await expect(promise).resolves.toEqual(mockServices);
+      expect(mockNoble.discoverServices).toHaveBeenCalledWith(mockId, 'uuids');
+      expect(mockNoble.discoverServices).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -308,74 +289,78 @@ describe('peripheral', () => {
     let mockServices = null;
 
     beforeEach(() => {
-      peripheral.discoverServices = sinon.stub();
+      peripheral.discoverServices = jest.fn((uuids, callback) => {
+        if (callback) callback(null, mockServices);
+      });
 
       mockServices = [
         {
           uuid: '1',
-          discoverCharacteristics: sinon.spy()
+          discoverCharacteristics: jest.fn((charUuids, callback) => {
+            if (callback) callback(null, []);
+          })
         },
         {
           uuid: '2',
-          discoverCharacteristics: sinon.spy()
+          discoverCharacteristics: jest.fn((charUuids, callback) => {
+            if (callback) callback(null, []);
+          })
         }
       ];
     });
 
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should call discoverServices', () => {
+    test('should call discoverServices', () => {
       peripheral.discoverSomeServicesAndCharacteristics(mockServiceUuids);
-      peripheral.discoverServices.callArg(1, null, mockServices);
+      
 
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      // expect(peripheral.discoverServices.mock.calls[0][0]).toEqual(mockServiceUuids);
+      expect(typeof peripheral.discoverServices.mock.calls[0][1]).toBe('function');
     });
 
-    it('should call discoverCharacteristics on each service discovered', () => {
+    test('should call discoverCharacteristics on each service discovered', () => {
       peripheral.discoverSomeServicesAndCharacteristics(mockServiceUuids, mockCharacteristicUuids);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[0].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[1].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
+      
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      expect(mockServices[0].discoverCharacteristics).toHaveBeenCalled();
+      expect(mockServices[1].discoverCharacteristics).toHaveBeenCalled();
+      
+      // expect(mockServices[0].discoverCharacteristics.mock.calls[0][0]).toEqual(mockCharacteristicUuids);
+      expect(typeof mockServices[0].discoverCharacteristics.mock.calls[0][1]).toBe('function');
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       peripheral.discoverSomeServicesAndCharacteristics(mockServiceUuids, mockCharacteristicUuids, callback);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[0].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[1].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-
-      mockServices[0].discoverCharacteristics.callArg(1, null, mockCharacteristicUuids);
-      mockServices[1].discoverCharacteristics.callArg(1, null, mockCharacteristicUuids);
-
-      assert.calledOnceWithExactly(callback, null, mockServices, mockCharacteristicUuids);
+      
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      expect(mockServices[0].discoverCharacteristics).toHaveBeenCalled();
+      expect(mockServices[1].discoverCharacteristics).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(null, mockServices, []);
     });
 
-    it('should callback with the services and characteristics discovered', () => {
-      const callback = sinon.spy();
-
-      peripheral.discoverSomeServicesAndCharacteristics(mockServiceUuids, mockCharacteristicUuids, callback);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
+    test('should callback with the services and characteristics discovered', () => {
+      const callback = jest.fn();
       const mockCharacteristic1 = { uuid: '1' };
       const mockCharacteristic2 = { uuid: '2' };
       const mockCharacteristic3 = { uuid: '3' };
 
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[0].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[1].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-
-      mockServices[0].discoverCharacteristics.callArg(1, null, [mockCharacteristic1]);
-      mockServices[1].discoverCharacteristics.callArg(1, null, [mockCharacteristic2, mockCharacteristic3]);
+      mockServices[0].discoverCharacteristics = jest.fn((charUuids, callback) => {
+        if (callback) callback(null, [mockCharacteristic1]);
+      });
+      
+      mockServices[1].discoverCharacteristics = jest.fn((charUuids, callback) => {
+        if (callback) callback(null, [mockCharacteristic2, mockCharacteristic3]);
+      });
 
-      assert.calledOnceWithExactly(callback, null, mockServices, [mockCharacteristic1, mockCharacteristic2, mockCharacteristic3]);
+      peripheral.discoverSomeServicesAndCharacteristics(mockServiceUuids, mockCharacteristicUuids, callback);
+      
+      expect(callback).toHaveBeenCalledWith(
+        null, 
+        mockServices, 
+        [mockCharacteristic1, mockCharacteristic2, mockCharacteristic3]
+      );
     });
   });
 
@@ -385,239 +370,424 @@ describe('peripheral', () => {
     let mockServices = null;
 
     beforeEach(() => {
-      peripheral.discoverServices = sinon.stub();
+      peripheral.discoverServices = jest.fn();
 
       mockServices = [
         {
           uuid: '1',
-          discoverCharacteristics: sinon.spy()
+          discoverCharacteristics: jest.fn()
         },
         {
           uuid: '2',
-          discoverCharacteristics: sinon.spy()
+          discoverCharacteristics: jest.fn()
         }
       ];
     });
 
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should call discoverServices', async () => {
+    test('should call discoverServices', async () => {
       const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
-      should(promise).resolvedWith([]);
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-    });
-
-    it('should call discoverCharacteristics on each service discovered', () => {
+      
+      // Call the callback passed to discoverServices
+      peripheral.discoverServices.mock.calls[0][1](null, mockServices);
+      
+      // Call the callbacks for each service's discoverCharacteristics
+      mockServices[0].discoverCharacteristics.mock.calls[0][1](null, []);
+      mockServices[1].discoverCharacteristics.mock.calls[0][1](null, []);
+      
+      await expect(promise).resolves.toEqual({ characteristics: [], services: mockServices });
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      expect(peripheral.discoverServices.mock.calls[0][0]).toEqual(mockServiceUuids);
+    });
+
+    test('should call discoverCharacteristics on each service discovered', async () => {
       const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids, mockCharacteristicUuids);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
-      should(promise).resolvedWith([]);
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[0].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[1].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-    });
-
-    it('should reject on error', async () => {
+      
+      // Call the callback passed to discoverServices
+      peripheral.discoverServices.mock.calls[0][1](null, mockServices);
+      
+      // Call the callbacks for each service's discoverCharacteristics
+      mockServices[0].discoverCharacteristics.mock.calls[0][1](null, []);
+      mockServices[1].discoverCharacteristics.mock.calls[0][1](null, []);
+      
+      await expect(promise).resolves.toEqual({ characteristics: [], services: mockServices });
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      expect(mockServices[0].discoverCharacteristics).toHaveBeenCalled();
+      expect(mockServices[1].discoverCharacteristics).toHaveBeenCalled();
+    });
+
+    test('should reject on error', async () => {
       const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids, mockCharacteristicUuids);
-      peripheral.discoverServices.callArg(1, 'error', null);
-
-      should(promise).rejectedWith('error');
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.notCalled(mockServices[0].discoverCharacteristics);
+      
+      // Call the callback passed to discoverServices with an error
+      peripheral.discoverServices.mock.calls[0][1]('error', null);
+      
+      await expect(promise).rejects.toEqual('error');
+      expect(peripheral.discoverServices).toHaveBeenCalled();
+      expect(mockServices[0].discoverCharacteristics).not.toHaveBeenCalled();
     });
 
-    it('should resolve with the services and characteristics discovered', async () => {
-      const callback = sinon.spy();
-
-      const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids, mockCharacteristicUuids, callback);
-      peripheral.discoverServices.callArg(1, null, mockServices);
-
+    test('should resolve with the services and characteristics discovered', async () => {
       const mockCharacteristic1 = { uuid: '1' };
       const mockCharacteristic2 = { uuid: '2' };
       const mockCharacteristic3 = { uuid: '3' };
 
-      assert.calledOnceWithMatch(peripheral.discoverServices, mockServiceUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[0].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-      assert.calledOnceWithMatch(mockServices[1].discoverCharacteristics, mockCharacteristicUuids, sinon.match.func);
-
-      mockServices[0].discoverCharacteristics.callArg(1, null, [mockCharacteristic1]);
-      mockServices[1].discoverCharacteristics.callArg(1, null, [mockCharacteristic2, mockCharacteristic3]);
-
-      should(promise).resolvedWith([mockCharacteristic1, mockCharacteristic2, mockCharacteristic3]);
+      const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids, mockCharacteristicUuids);
+      
+      // Call the callback passed to discoverServices
+      peripheral.discoverServices.mock.calls[0][1](null, mockServices);
+      
+      // Call the callbacks for each service's discoverCharacteristics
+      mockServices[0].discoverCharacteristics.mock.calls[0][1](null, [mockCharacteristic1]);
+      mockServices[1].discoverCharacteristics.mock.calls[0][1](null, [mockCharacteristic2, mockCharacteristic3]);
+      
+      await expect(promise).resolves.toEqual({ characteristics: [mockCharacteristic1, mockCharacteristic2, mockCharacteristic3], services: mockServices });
+    });
+
+    test('should reject when disconnect happens during execution', async () => {
+      const mockServiceUuids = [];
+      const mockCharacteristicUuids = [];
+      
+      // Override the implementation of _withDisconnectHandler to simulate disconnect during operation
+      mockNoble._withDisconnectHandler = jest.fn((id, operation) => {
+        return new Promise((resolve, reject) => {
+          // Start the operation
+          const operationPromise = operation();
+          
+          // Simulate a disconnect by rejecting with a disconnect error
+          setTimeout(() => {
+            reject(new Error('Peripheral disconnected'));
+          }, 10);
+          
+          return operationPromise;
+        });
+      });
+      
+      // Start the async operation
+      const promise = peripheral.discoverSomeServicesAndCharacteristicsAsync(mockServiceUuids, mockCharacteristicUuids);
+      
+      // Verify the promise rejects
+      await expect(promise).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+      
+      // Restore original implementation
+      mockNoble._withDisconnectHandler = jest.fn((id, operation) => {
+        return new Promise((resolve, reject) => {
+          return Promise.resolve(operation())
+            .then(result => {
+              resolve(result);
+            })
+            .catch(error => {
+              reject(error);
+            });
+        });
+      });
     });
   });
 
   describe('discoverAllServicesAndCharacteristics', () => {
     beforeEach(() => {
-      peripheral.discoverSomeServicesAndCharacteristics = sinon.stub();
-    });
-
-    afterEach(() => {
-      sinon.reset();
+      peripheral.discoverSomeServicesAndCharacteristics = jest.fn();
     });
 
-    it('should call discoverSomeServicesAndCharacteristics', () => {
-      const callback = sinon.spy();
+    test('should call discoverSomeServicesAndCharacteristics', () => {
+      const callback = jest.fn();
       peripheral.discoverAllServicesAndCharacteristics(callback);
-      assert.calledOnceWithExactly(peripheral.discoverSomeServicesAndCharacteristics, [], [], callback);
+      expect(peripheral.discoverSomeServicesAndCharacteristics).toHaveBeenCalledWith([], [], callback);
     });
   });
 
   describe('discoverAllServicesAndCharacteristicsAsync', () => {
     beforeEach(() => {
-      peripheral.discoverSomeServicesAndCharacteristics = sinon.stub();
-    });
-
-    afterEach(() => {
-      sinon.reset();
+      peripheral.discoverAllServicesAndCharacteristics = jest.fn();
     });
-
-    it('should call discoverSomeServicesAndCharacteristics', async () => {
+  
+    test('should call discoverAllServicesAndCharacteristics with a callback', async () => {
+      const promise = peripheral.discoverAllServicesAndCharacteristicsAsync();
+      
+      // Find the callback that was passed to discoverAllServicesAndCharacteristics
+      const callback = peripheral.discoverAllServicesAndCharacteristics.mock.calls[0][0];
+      
+      // Simulate successful callback
+      const mockServices = ['service1', 'service2'];
+      const mockCharacteristics = ['char1', 'char2'];
+      callback(null, mockServices, mockCharacteristics);
+      
+      const result = await promise;
+      expect(result).toEqual({ services: mockServices, characteristics: mockCharacteristics });
+      expect(peripheral.discoverAllServicesAndCharacteristics).toHaveBeenCalledTimes(1);
+    });
+  
+    test('should reject when discoverAllServicesAndCharacteristics returns an error', async () => {
       const promise = peripheral.discoverAllServicesAndCharacteristicsAsync();
-      peripheral.discoverSomeServicesAndCharacteristics.callArg(2, null);
-      should(promise).resolvedWith([]);
+      
+      // Find the callback that was passed to discoverAllServicesAndCharacteristics
+      const callback = peripheral.discoverAllServicesAndCharacteristics.mock.calls[0][0];
+      
+      // Simulate error callback
+      const mockError = new Error('Discovery failed');
+      callback(mockError);
+      
+      await expect(promise).rejects.toEqual(mockError);
+      expect(peripheral.discoverAllServicesAndCharacteristics).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('readHandle', () => {
-    beforeEach(() => {
-      mockNoble.readHandle = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       peripheral.readHandle(mockHandle);
-      assert.calledOnceWithExactly(mockNoble.readHandle, mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledWith(mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       peripheral.readHandle(mockHandle, callback);
       peripheral.emit(`handleRead${mockHandle}`);
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(mockNoble.readHandle, mockId, mockHandle);
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.readHandle).toHaveBeenCalledWith(mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with data', () => {
-      const callback = sinon.spy();
+    test('should callback with data', () => {
+      const callback = jest.fn();
 
       peripheral.readHandle(mockHandle, callback);
       peripheral.emit(`handleRead${mockHandle}`, mockData);
 
-      assert.calledOnceWithExactly(callback, null, mockData);
-      assert.calledOnceWithExactly(mockNoble.readHandle, mockId, mockHandle);
+      expect(callback).toHaveBeenCalledWith(undefined, mockData);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.readHandle).toHaveBeenCalledWith(mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('readHandleAsync', () => {
-    beforeEach(() => {
-      mockNoble.readHandle = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = peripheral.readHandleAsync(mockHandle);
       peripheral.emit(`handleRead${mockHandle}`);
 
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(mockNoble.readHandle, mockId, mockHandle);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.readHandle).toHaveBeenCalledWith(mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve with data', async () => {
+    test('should resolve with data', async () => {
       const promise = peripheral.readHandleAsync(mockHandle);
       peripheral.emit(`handleRead${mockHandle}`, mockData);
 
-      should(promise).resolvedWith(mockData);
-      assert.calledOnceWithExactly(mockNoble.readHandle, mockId, mockHandle);
+      await expect(promise).resolves.toEqual(mockData);
+      expect(mockNoble.readHandle).toHaveBeenCalledWith(mockId, mockHandle);
+      expect(mockNoble.readHandle).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('writeHandle', () => {
-    beforeEach(() => {
-      mockNoble.writeHandle = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should only accept data as a buffer', () => {
+    test('should only accept data as a buffer', () => {
       const mockData = {};
-      should(() => peripheral.writeHandle(mockHandle, mockData)).throw('data must be a Buffer');
-      assert.notCalled(mockNoble.writeHandle);
+      expect(() => peripheral.writeHandle(mockHandle, mockData)).toThrow('data must be a Buffer');
+      expect(mockNoble.writeHandle).not.toHaveBeenCalled();
     });
 
-    it('should delegate to noble, withoutResponse false', () => {
+    test('should delegate to noble, withoutResponse false', () => {
       const mockData = Buffer.alloc(0);
       peripheral.writeHandle(mockHandle, mockData, false);
 
-      assert.alwaysCalledWithExactly(mockNoble.writeHandle, mockId, mockHandle, mockData, false);
+      expect(mockNoble.writeHandle).toHaveBeenCalledWith(mockId, mockHandle, mockData, false);
+      expect(mockNoble.writeHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, withoutResponse true', () => {
+    test('should delegate to noble, withoutResponse true', () => {
       const mockData = Buffer.alloc(0);
       peripheral.writeHandle(mockHandle, mockData, true);
 
-      assert.alwaysCalledWithExactly(mockNoble.writeHandle, mockId, mockHandle, mockData, true);
+      expect(mockNoble.writeHandle).toHaveBeenCalledWith(mockId, mockHandle, mockData, true);
+      expect(mockNoble.writeHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
+    test('should callback', () => {
       const mockData = Buffer.alloc(0);
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       peripheral.writeHandle(mockHandle, mockData, false, callback);
       peripheral.emit(`handleWrite${mockHandle}`);
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.alwaysCalledWithExactly(mockNoble.writeHandle, mockId, mockHandle, mockData, false);
+      expect(callback).toHaveBeenCalledWith(undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.writeHandle).toHaveBeenCalledWith(mockId, mockHandle, mockData, false);
+      expect(mockNoble.writeHandle).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('writeHandleAsync', () => {
-    beforeEach(() => {
-      mockNoble.writeHandle = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should only accept data as a buffer', async () => {
+    test('should only accept data as a buffer', async () => {
       const mockData = {};
-      const promise = peripheral.writeHandleAsync(mockHandle, mockData);
-
-      should(promise).rejectedWith('data must be a Buffer');
-      assert.notCalled(mockNoble.writeHandle);
+      
+      await expect(peripheral.writeHandleAsync(mockHandle, mockData)).rejects.toThrow('data must be a Buffer');
+      expect(mockNoble.writeHandle).not.toHaveBeenCalled();
     });
 
-    it('should delegate to noble, withoutResponse false', async () => {
+    test('should delegate to noble, withoutResponse false', async () => {
       const mockData = Buffer.alloc(0);
       const promise = peripheral.writeHandleAsync(mockHandle, mockData, false);
       peripheral.emit(`handleWrite${mockHandle}`);
 
-      should(promise).resolvedWith(null);
-      assert.alwaysCalledWithExactly(mockNoble.writeHandle, mockId, mockHandle, mockData, false);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.writeHandle).toHaveBeenCalledWith(mockId, mockHandle, mockData, false);
+      expect(mockNoble.writeHandle).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, withoutResponse true', async () => {
+    test('should delegate to noble, withoutResponse true', async () => {
       const mockData = Buffer.alloc(0);
       const promise = peripheral.writeHandleAsync(mockHandle, mockData, true);
       peripheral.emit(`handleWrite${mockHandle}`);
 
-      should(promise).resolvedWith(null);
-      assert.alwaysCalledWithExactly(mockNoble.writeHandle, mockId, mockHandle, mockData, true);
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.writeHandle).toHaveBeenCalledWith(mockId, mockHandle, mockData, true);
+      expect(mockNoble.writeHandle).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('async commands with disconnect handling', () => {
+    // Setup a reusable helper to manage the original and mocked _withDisconnectHandler
+    let originalWithDisconnectHandler;
+    
+    const setupDisconnectMock = (simulateDisconnect = true, disconnectDelay = 10) => {
+      // Save the original implementation
+      originalWithDisconnectHandler = mockNoble._withDisconnectHandler;
+      
+      // Create the mock implementation
+      mockNoble._withDisconnectHandler = jest.fn((id, operation) => {
+        return new Promise((resolve, reject) => {
+          // Start the operation
+          const operationPromise = operation();
+          
+          if (simulateDisconnect) {
+            // Simulate a disconnect by rejecting with a disconnect error
+            setTimeout(() => {
+              reject(new Error('Peripheral disconnected'));
+            }, disconnectDelay);
+          }
+          
+          return operationPromise;
+        });
+      });
+    };
+    
+    const restoreDisconnectMock = () => {
+      // Restore the original implementation
+      mockNoble._withDisconnectHandler = originalWithDisconnectHandler;
+    };
+    
+    afterEach(() => {
+      // Always restore after each test
+      restoreDisconnectMock();
+    });
+    
+    test('discoverServicesAsync should handle disconnect during operation', async () => {
+      setupDisconnectMock();
+      
+      const promise = peripheral.discoverServicesAsync();
+      
+      await expect(promise).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+    });
+    
+    test('updateRssiAsync should handle disconnect during operation', async () => {
+      setupDisconnectMock();
+      
+      const promise = peripheral.updateRssiAsync();
+      
+      await expect(promise).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+    });
+    
+    test('readHandleAsync should handle disconnect during operation', async () => {
+      setupDisconnectMock();
+      
+      const promise = peripheral.readHandleAsync(mockHandle);
+      
+      await expect(promise).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+    });
+    
+    test('writeHandleAsync should handle disconnect during operation', async () => {
+      setupDisconnectMock();
+      
+      const mockData = Buffer.alloc(0);
+      const promise = peripheral.writeHandleAsync(mockHandle, mockData, false);
+      
+      await expect(promise).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+    });
+    
+    test('chain of async operations should all fail on disconnect', async () => {
+      // We'll run without disconnect initially
+      setupDisconnectMock(false);
+      
+      // Setup mock responses for service discovery
+      const mockCharacteristic = { uuid: '1' };
+      const mockService = {
+        uuid: '1',
+        discoverCharacteristics: jest.fn((charUuids, callback) => {
+          callback(null, [mockCharacteristic]);
+        })
+      };
+      
+      peripheral.discoverServices = jest.fn((uuids, callback) => {
+        callback(null, [mockService]);
+      });
+      
+      // Start a chain of operations
+      const runOperations = async () => {
+
+        setTimeout(() => peripheral.emit('connect'), 20);
+
+        // First operation succeeds
+        await peripheral.connectAsync();
+        
+        // Enable disconnection before second operation
+        setupDisconnectMock(true, 5);
+        
+        // This should fail with disconnect
+        await peripheral.discoverAllServicesAndCharacteristics();
+        
+        // These should never be reached
+        await peripheral.readHandleAsync(mockHandle);
+        await peripheral.writeHandleAsync(mockHandle, Buffer.alloc(0));
+        
+        return 'completed';
+      };
+      
+      await expect(runOperations()).rejects.toEqual(expect.objectContaining({
+        message: 'Peripheral disconnected'
+      }));
+    });
+    
+    test('multiple concurrent async operations should all fail on disconnect', async () => {
+      setupDisconnectMock(true, 5);
+      
+      // Start multiple operations at the same time
+      const promises = [
+        peripheral.updateRssiAsync(),
+        peripheral.discoverServicesAsync(),
+        peripheral.readHandleAsync(mockHandle),
+        peripheral.writeHandleAsync(mockHandle, Buffer.alloc(0))
+      ];
+      
+      // All operations should fail with the same disconnect error
+      await Promise.all(promises.map(promise => 
+        expect(promise).rejects.toEqual(expect.objectContaining({
+          message: 'Peripheral disconnected'
+        }))
+      ));
     });
   });
-});
+});