@stoprocent/noble 1.19.0 → 2.0.0

package/test/lib/characteristic.test.js

@@ -1,8 +1,3 @@
-const sinon = require('sinon');
-const should = require('should');
-
-const { assert } = sinon;
-
 const Characteristic = require('../../lib/characteristic');
 
 describe('characteristic', () => {
@@ -15,7 +10,16 @@ describe('characteristic', () => {
   let characteristic = null;
 
   beforeEach(() => {
-    mockNoble = {};
+    mockNoble = {
+      _withDisconnectHandler: (id, operation) => {
+        return operation();
+      },
+      read: jest.fn(),
+      write: jest.fn(),
+      broadcast: jest.fn(),
+      notify: jest.fn(),
+      discoverDescriptors: jest.fn()
+    };
 
     characteristic = new Characteristic(
       mockNoble,
@@ -26,11 +30,15 @@ describe('characteristic', () => {
     );
   });
 
-  it('should have a uuid', () => {
-    should(characteristic.uuid).equal(mockUuid);
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should lookup name and type by uuid', () => {
+  test('should have a uuid', () => {
+    expect(characteristic.uuid).toEqual(mockUuid);
+  });
+
+  test('should lookup name and type by uuid', () => {
     characteristic = new Characteristic(
       mockNoble,
       mockPeripheralId,
@@ -39,62 +47,55 @@ describe('characteristic', () => {
       mockProperties
     );
 
-    should(characteristic.name).equal('Device Name');
-    should(characteristic.type).equal(
+    expect(characteristic.name).toEqual('Device Name');
+    expect(characteristic.type).toEqual(
       'org.bluetooth.characteristic.gap.device_name'
     );
   });
 
-  it('should have properties', () => {
-    should(characteristic.properties).equal(mockProperties);
+  test('should have properties', () => {
+    expect(characteristic.properties).toEqual(mockProperties);
   });
 
   describe('toString', () => {
-    it('should be uuid, name, type, properties', () => {
-      should(characteristic.toString()).equal(
+    test('should be uuid, name, type, properties', () => {
+      expect(characteristic.toString()).toEqual(
         '{"uuid":"mock-uuid","name":null,"type":null,"properties":["mock-property-1","mock-property-2"]}'
       );
     });
   });
 
   describe('read', () => {
-    beforeEach(() => {
-      mockNoble.read = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       characteristic.read();
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback without data', () => {
-      const callback = sinon.spy();
+    test('should callback without data', () => {
+      const callback = jest.fn();
 
       characteristic.read(callback);
       characteristic.emit('read');
       // Check for single callback
       characteristic.emit('read');
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with data', () => {
-      const callback = sinon.spy();
+    test('should callback with data', () => {
+      const callback = jest.fn();
       const data = 'data';
 
       characteristic.read(callback);
@@ -102,17 +103,18 @@ describe('characteristic', () => {
       // Check for single callback
       characteristic.emit('read', data);
 
-      assert.calledOnceWithExactly(callback, null, data);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      expect(callback).toHaveBeenCalledWith(undefined, data);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
-    it('should not callback as it is notification', () => {
-      const callback = sinon.spy();
+    test('should not callback as it is notification', () => {
+      const callback = jest.fn();
       const data = 'data';
 
       characteristic.read(callback);
@@ -120,616 +122,505 @@ describe('characteristic', () => {
       // Check for single callback
       characteristic.emit('read', data, true);
 
-      assert.notCalled(callback);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      expect(callback).not.toHaveBeenCalled();
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('readAsync', () => {
-    beforeEach(() => {
-      mockNoble.read = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = characteristic.readAsync();
       characteristic.emit('read');
-      // Check for single callback
-      characteristic.emit('read');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
-    it('should returns without data', async () => {
+    test('should returns without data', async () => {
       const promise = characteristic.readAsync();
       characteristic.emit('read');
-      // Check for single callback
-      characteristic.emit('read');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with data', async () => {
+    test('should callback with data', async () => {
       const data = 'data';
 
       const promise = characteristic.readAsync();
       characteristic.emit('read', data);
-      // Check for single callback
-      characteristic.emit('read', data);
-
-      should(promise).resolvedWith(data);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      
+      await expect(promise).resolves.toEqual(data);
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
 
     // This shows that async notification never ends
-    it.skip('should not callback as it is notification', async () => {
+    test.skip('should not callback as it is notification', async () => {
       const data = 'data';
 
       const promise = characteristic.readAsync();
       characteristic.emit('read', data, true);
-      // Check for single callback
-      characteristic.emit('read', data, true);
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.read,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.read).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.read).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('write', () => {
     let processTitle = null;
+    
     beforeEach(() => {
-      mockNoble.write = sinon.spy();
       processTitle = process.title;
     });
 
     afterEach(() => {
-      sinon.reset();
       process.title = processTitle;
     });
 
-    it('should only accept data as a buffer', () => {
-      should(() => characteristic.write({})).throw(
+    test('should only accept data as a buffer', () => {
+      expect(() => characteristic.write({})).toThrow(
         'data must be a Buffer or Uint8Array or Uint16Array or Uint32Array'
       );
 
-      assert.notCalled(mockNoble.write);
+      expect(mockNoble.write).not.toHaveBeenCalled();
     });
 
-    it('should accept any kind of data as process is browser', () => {
+    test('should accept any kind of data as process is browser', () => {
       process.title = 'browser';
 
       const mockData = {};
       characteristic.write(mockData);
 
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         undefined
       );
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, withoutResponse false', () => {
+    test('should delegate to noble, withoutResponse false', () => {
       const mockData = Buffer.alloc(0);
       characteristic.write(mockData, false);
 
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         false
       );
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, withoutResponse true', () => {
+    test('should delegate to noble, withoutResponse true', () => {
       const mockData = Buffer.alloc(0);
       characteristic.write(mockData, true);
 
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         true
       );
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
+    test('should callback', () => {
       const mockData = Buffer.alloc(0);
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       characteristic.write(mockData, true, callback);
       characteristic.emit('write');
       // Check for single callback
       characteristic.emit('write');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      expect(callback).toHaveBeenCalledWith(undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         true
       );
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('writeAsync', () => {
-    beforeEach(() => {
-      mockNoble.write = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should only accept data as a buffer', async () => {
-      const promise = characteristic.writeAsync({});
-      should(promise).rejectedWith(
+    test('should only accept data as a buffer', async () => {
+      await expect(characteristic.writeAsync({})).rejects.toThrow(
         'data must be a Buffer or Uint8Array or Uint16Array or Uint32Array'
       );
 
-      assert.notCalled(mockNoble.write);
+      expect(mockNoble.write).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 = characteristic.writeAsync(mockData, false);
       characteristic.emit('write');
-      // Check for single callback
-      characteristic.emit('write');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         false
       );
+      expect(mockNoble.write).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 = characteristic.writeAsync(mockData, true);
       characteristic.emit('write');
-      // Check for single callback
-      characteristic.emit('write');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.write,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.write).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         mockData,
         true
       );
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve', async () => {
+    test('should resolve', async () => {
       const mockData = Buffer.alloc(0);
       const promise = characteristic.writeAsync(mockData, true);
       characteristic.emit('write');
-      // Check for single callback
-      characteristic.emit('write');
-
-      should(promise).resolvedWith(undefined);
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.write).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('broadcast', () => {
-    beforeEach(() => {
-      mockNoble.broadcast = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble, true', () => {
+    test('should delegate to noble, true', () => {
       characteristic.broadcast(true);
 
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, false', () => {
+    test('should delegate to noble, false', () => {
       characteristic.broadcast(false);
 
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       characteristic.broadcast(true, callback);
       characteristic.emit('broadcast');
       // Check for single callback
       characteristic.emit('broadcast');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      expect(callback).toHaveBeenCalledWith(undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('broadcastAsync', () => {
-    beforeEach(() => {
-      mockNoble.broadcast = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble, true', async () => {
+    test('should delegate to noble, true', async () => {
       const promise = characteristic.broadcastAsync(true);
       characteristic.emit('broadcast');
-      // Check for single callback
-      characteristic.emit('broadcast');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, false', async () => {
+    test('should delegate to noble, false', async () => {
       const promise = characteristic.broadcastAsync(false);
       characteristic.emit('broadcast');
-      // Check for single callback
-      characteristic.emit('broadcast');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve', async () => {
+    test('should resolve', async () => {
       const promise = characteristic.broadcastAsync(true);
       characteristic.emit('broadcast');
-      // Check for single callback
-      characteristic.emit('broadcast');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.broadcast,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.broadcast).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.broadcast).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('notify', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble, true', () => {
+    test('should delegate to noble, true', () => {
       characteristic.notify(true);
 
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, false', () => {
+    test('should delegate to noble, false', () => {
       characteristic.notify(false);
 
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       characteristic.notify(true, callback);
       characteristic.emit('notify');
       // Check for single callback
       characteristic.emit('notify');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('notifyAsync', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble, true', async () => {
+    test('should delegate to noble, true', async () => {
       const promise = characteristic.notifyAsync(true);
       characteristic.emit('notify');
-      // Check for single callback
-      characteristic.emit('notify');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
 
-    it('should delegate to noble, false', async () => {
+    test('should delegate to noble, false', async () => {
       const promise = characteristic.notifyAsync(false);
       characteristic.emit('notify');
-      // Check for single callback
-      characteristic.emit('notify');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('subscribe', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble notify, true', () => {
+    test('should delegate to noble notify, true', () => {
       characteristic.subscribe();
 
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       characteristic.subscribe(callback);
       characteristic.emit('notify');
       // Check for single callback
       characteristic.emit('notify');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('subscribeAsync', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble notify, true', async () => {
+    test('should delegate to noble notify, true', async () => {
       const promise = characteristic.subscribeAsync();
       characteristic.emit('notify');
-      // Check for single callback
-      characteristic.emit('notify');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         true
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('unsubscribe', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble notify, false', () => {
+    test('should delegate to noble notify, false', () => {
       characteristic.unsubscribe();
 
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       characteristic.unsubscribe(callback);
       characteristic.emit('notify');
       // Check for single callback
       characteristic.emit('notify');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('unsubscribeAsync', () => {
-    beforeEach(() => {
-      mockNoble.notify = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble notify, false', async () => {
+    test('should delegate to noble notify, false', async () => {
       const promise = characteristic.unsubscribeAsync();
       characteristic.emit('notify');
-      // Check for single callback
-      characteristic.emit('notify');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.notify,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid,
         false
       );
+      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverDescriptors', () => {
-    beforeEach(() => {
-      mockNoble.discoverDescriptors = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       characteristic.discoverDescriptors();
 
-      assert.calledOnceWithExactly(
-        mockNoble.discoverDescriptors,
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback, undefined descriptors', () => {
-      const callback = sinon.spy();
+    test('should callback, undefined descriptors', () => {
+      const callback = jest.fn();
 
       characteristic.discoverDescriptors(callback);
       characteristic.emit('descriptorsDiscover');
       // Check for single callback
       characteristic.emit('descriptorsDiscover');
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.discoverDescriptors,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with descriptors', () => {
-      const callback = sinon.spy();
+    test('should callback with descriptors', () => {
+      const callback = jest.fn();
       const descriptors = 'descriptors';
 
       characteristic.discoverDescriptors(callback);
@@ -737,55 +628,44 @@ describe('characteristic', () => {
       // Check for single callback
       characteristic.emit('descriptorsDiscover', descriptors);
 
-      assert.calledOnceWithExactly(callback, null, descriptors);
-      assert.calledOnceWithExactly(
-        mockNoble.discoverDescriptors,
+      expect(callback).toHaveBeenCalledWith(undefined, descriptors);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('discoverDescriptorsAsync', () => {
-    beforeEach(() => {
-      mockNoble.discoverDescriptors = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = characteristic.discoverDescriptorsAsync();
       characteristic.emit('descriptorsDiscover');
-      // Check for single callback
-      characteristic.emit('descriptorsDiscover');
-
-      should(promise).resolvedWith(null, undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.discoverDescriptors,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve with descriptors', async () => {
+    test('should resolve with descriptors', async () => {
       const descriptors = 'descriptors';
 
       const promise = characteristic.discoverDescriptorsAsync();
       characteristic.emit('descriptorsDiscover', descriptors);
-      // Check for single callback
-      characteristic.emit('descriptorsDiscover', descriptors);
-
-      should(promise).resolvedWith(null, descriptors);
-      assert.calledOnceWithExactly(
-        mockNoble.discoverDescriptors,
+      
+      await expect(promise).resolves.toEqual(descriptors);
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockUuid
       );
+      expect(mockNoble.discoverDescriptors).toHaveBeenCalledTimes(1);
     });
   });
-});
+});