@stoprocent/noble 1.19.0 → 2.0.0

package/test/lib/descriptor.test.js

@@ -1,8 +1,3 @@
-const sinon = require('sinon');
-const should = require('should');
-
-const { assert } = sinon;
-
 const Descriptor = require('../../lib/descriptor');
 
 describe('descriptor', () => {
@@ -15,7 +10,10 @@ describe('descriptor', () => {
   let descriptor = null;
 
   beforeEach(() => {
-    mockNoble = {};
+    mockNoble = {
+      readValue: jest.fn(),
+      writeValue: jest.fn()
+    };
 
     descriptor = new Descriptor(
       mockNoble,
@@ -26,11 +24,15 @@ describe('descriptor', () => {
     );
   });
 
-  it('should have a uuid', () => {
-    should(descriptor.uuid).equal(mockUuid);
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should lookup name and type by uuid', () => {
+  test('should have a uuid', () => {
+    expect(descriptor.uuid).toEqual(mockUuid);
+  });
+
+  test('should lookup name and type by uuid', () => {
     descriptor = new Descriptor(
       mockNoble,
       mockPeripheralId,
@@ -39,211 +41,176 @@ describe('descriptor', () => {
       '2900'
     );
 
-    should(descriptor.name).equal('Characteristic Extended Properties');
-    should(descriptor.type).equal(
+    expect(descriptor.name).toEqual('Characteristic Extended Properties');
+    expect(descriptor.type).toEqual(
       'org.bluetooth.descriptor.gatt.characteristic_extended_properties'
     );
   });
 
   describe('toString', () => {
-    it('should be uuid, name, type', () => {
-      should(descriptor.toString()).equal(
+    test('should be uuid, name, type', () => {
+      expect(descriptor.toString()).toEqual(
         '{"uuid":"mock-uuid","name":null,"type":null}'
       );
     });
   });
 
   describe('readValue', () => {
-    beforeEach(() => {
-      mockNoble.readValue = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       descriptor.readValue();
 
-      assert.calledOnceWithExactly(
-        mockNoble.readValue,
+      expect(mockNoble.readValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid
       );
+      expect(mockNoble.readValue).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
-      const callback = sinon.spy();
+    test('should callback', () => {
+      const callback = jest.fn();
 
       descriptor.readValue(callback);
       descriptor.emit('valueRead');
       // Check for single callback
       descriptor.emit('valueRead');
 
-      assert.calledOnceWithExactly(callback, null, undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.readValue,
+      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.readValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid
       );
+      expect(mockNoble.readValue).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback with error, data', () => {
+    test('should callback with error, data', () => {
       const mockData = Buffer.alloc(0);
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       descriptor.readValue(callback);
       descriptor.emit('valueRead', mockData);
       // Check for single callback
       descriptor.emit('valueRead', mockData);
 
-      assert.calledOnceWithExactly(callback, null, mockData);
-      assert.calledOnceWithExactly(
-        mockNoble.readValue,
+      expect(callback).toHaveBeenCalledWith(undefined, mockData);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.readValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid
       );
+      expect(mockNoble.readValue).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('readValueAsync', () => {
-    beforeEach(() => {
-      mockNoble.readValue = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const promise = descriptor.readValueAsync();
       descriptor.emit('valueRead');
-      // Check for single callback
-      descriptor.emit('valueRead');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.readValue,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.readValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid
       );
+      expect(mockNoble.readValue).toHaveBeenCalledTimes(1);
     });
 
-    it('should resolve with data', async () => {
+    test('should resolve with data', async () => {
       const mockData = Buffer.alloc(0);
 
       const promise = descriptor.readValueAsync();
       descriptor.emit('valueRead', mockData);
-      // Check for single callback
-      descriptor.emit('valueRead', mockData);
-
-      should(promise).resolvedWith(mockData);
-      assert.calledOnceWithExactly(
-        mockNoble.readValue,
+      
+      await expect(promise).resolves.toEqual(mockData);
+      expect(mockNoble.readValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid
       );
+      expect(mockNoble.readValue).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('writeValue', () => {
-    beforeEach(() => {
-      mockNoble.writeValue = sinon.spy();
-    });
-
-    afterEach(() => {
-      sinon.reset();
-    });
-
-    it('should only accept data as a buffer', () => {
+    test('should only accept data as a buffer', () => {
       const mockData = {};
 
-      should(() => descriptor.writeValue(mockData)).throw(
+      expect(() => descriptor.writeValue(mockData)).toThrow(
         'data must be a Buffer'
       );
 
-      assert.notCalled(mockNoble.writeValue);
+      expect(mockNoble.writeValue).not.toHaveBeenCalled();
     });
 
-    it('should delegate to noble', () => {
+    test('should delegate to noble', () => {
       const mockData = Buffer.alloc(0);
       descriptor.writeValue(mockData);
 
-      assert.calledOnceWithExactly(
-        mockNoble.writeValue,
+      expect(mockNoble.writeValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid,
         mockData
       );
+      expect(mockNoble.writeValue).toHaveBeenCalledTimes(1);
     });
 
-    it('should callback', () => {
+    test('should callback', () => {
       const mockData = Buffer.alloc(0);
-      const callback = sinon.spy();
+      const callback = jest.fn();
 
       descriptor.writeValue(mockData, callback);
       descriptor.emit('valueWrite');
       // Check for single callback
       descriptor.emit('valueWrite');
 
-      assert.calledOnceWithExactly(callback, null);
-      assert.calledOnceWithExactly(
-        mockNoble.writeValue,
+      expect(callback).toHaveBeenCalledWith(undefined);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(mockNoble.writeValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid,
         mockData
       );
+      expect(mockNoble.writeValue).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('writeValueAsync', () => {
-    beforeEach(() => {
-      mockNoble.writeValue = 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 = descriptor.writeValueAsync(mockData);
-
-      should(promise).rejectedWith('data must be a Buffer');
+      await expect(descriptor.writeValueAsync(mockData)).rejects.toThrow(
+        'data must be a Buffer'
+      );
     });
 
-    it('should delegate to noble', async () => {
+    test('should delegate to noble', async () => {
       const mockData = Buffer.alloc(0);
 
       const promise = descriptor.writeValueAsync(mockData);
       descriptor.emit('valueWrite');
-      // Check for single callback
-      descriptor.emit('valueWrite');
-
-      should(promise).resolvedWith(undefined);
-      assert.calledOnceWithExactly(
-        mockNoble.writeValue,
+      
+      await expect(promise).resolves.toBeUndefined();
+      expect(mockNoble.writeValue).toHaveBeenCalledWith(
         mockPeripheralId,
         mockServiceUuid,
         mockCharacteristicUuid,
         mockUuid,
         mockData
       );
+      expect(mockNoble.writeValue).toHaveBeenCalledTimes(1);
     });
   });
-});
+});

package/test/lib/hci-socket/acl-stream.test.js

@@ -1,188 +1,192 @@
-const proxyquire = require('proxyquire').noCallThru();
-const should = require('should');
-const sinon = require('sinon');
-const { assert, fake, match } = sinon;
-
-describe('hci-socket acl-stream', () => {
-  const Smp = sinon.stub();
+const { jest: jestFn } = require('@jest/globals');
+
+// Use jest.mock instead of proxyquire
+jest.mock('../../../lib/hci-socket/smp', () => {
+  return jest.fn().mockImplementation(() => ({
+    on: jest.fn().mockResolvedValue(null),
+    removeListener: jest.fn().mockResolvedValue(null),
+    sendPairingRequest: jest.fn().mockResolvedValue(null)
+  }));
+});
 
-  const AclStream = proxyquire('../../../lib/hci-socket/acl-stream', {
-    './smp': Smp
-  });
+const Smp = require('../../../lib/hci-socket/smp');
+const AclStream = require('../../../lib/hci-socket/acl-stream');
 
+describe('hci-socket acl-stream', () => {
   beforeEach(() => {
-    Smp.prototype.on = fake.resolves(null);
-    Smp.prototype.removeListener = fake.resolves(null);
-  });
-
-  afterEach(() => {
-    sinon.reset();
+    jest.clearAllMocks();
   });
 
   it('constructor', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    should(aclStream._hci).eql(hci);
-    should(aclStream._handle).eql(handle);
-
-    should(aclStream._smp).instanceOf(Smp);
+    expect(aclStream._hci).toBe(hci);
+    expect(aclStream._handle).toBe(handle);
 
-    assert.calledOnce(Smp);
-    assert.calledWith(Smp, aclStream, localAddressType, localAddress, remoteAddressType, remoteAddress);
+    expect(Smp).toHaveBeenCalledTimes(1);
+    expect(Smp).toHaveBeenCalledWith(aclStream, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    assert.calledThrice(aclStream._smp.on);
-    assert.calledWith(aclStream._smp.on, 'stk', match.any);
-    assert.calledWith(aclStream._smp.on, 'fail', match.any);
-    assert.calledWith(aclStream._smp.on, 'end', match.any);
+    expect(aclStream._smp.on).toHaveBeenCalledTimes(3);
+    expect(aclStream._smp.on).toHaveBeenCalledWith('stk', expect.any(Function));
+    expect(aclStream._smp.on).toHaveBeenCalledWith('fail', expect.any(Function));
+    expect(aclStream._smp.on).toHaveBeenCalledWith('end', expect.any(Function));
   });
 
   it('encrypt', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    aclStream._smp.sendPairingRequest = fake.resolves(null);
-
     aclStream.encrypt();
 
-    assert.calledOnceWithExactly(aclStream._smp.sendPairingRequest);
+    expect(aclStream._smp.sendPairingRequest).toHaveBeenCalledTimes(1);
+    expect(aclStream._smp.sendPairingRequest).toHaveBeenCalledWith();
   });
 
   it('write', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
-    const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
+    hci.writeAclDataPkt = jest.fn().mockResolvedValue(null);
 
-    aclStream._hci.writeAclDataPkt = fake.resolves(null);
+    const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
     aclStream.write('cid', 'data');
 
-    assert.calledOnceWithExactly(aclStream._hci.writeAclDataPkt, handle, 'cid', 'data');
+    expect(hci.writeAclDataPkt).toHaveBeenCalledTimes(1);
+    expect(hci.writeAclDataPkt).toHaveBeenCalledWith(handle, 'cid', 'data');
   });
 
   it('push data', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    const eventEmmitted = fake.resolves(null);
-    aclStream.on('data', eventEmmitted);
+    const eventEmitted = jest.fn().mockResolvedValue(null);
+    aclStream.on('data', eventEmitted);
 
     aclStream.push('cid', 'data');
 
-    assert.calledOnceWithExactly(eventEmmitted, 'cid', 'data');
+    expect(eventEmitted).toHaveBeenCalledTimes(1);
+    expect(eventEmitted).toHaveBeenCalledWith('cid', 'data');
   });
 
   it('push no data', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    const eventEmmitted = fake.resolves(null);
-    aclStream.on('end', eventEmmitted);
+    const eventEmitted = jest.fn().mockResolvedValue(null);
+    aclStream.on('end', eventEmitted);
 
     aclStream.push('cid');
 
-    assert.calledOnceWithExactly(eventEmmitted);
+    expect(eventEmitted).toHaveBeenCalledTimes(1);
+    expect(eventEmitted).toHaveBeenCalledWith();
   });
 
   it('pushEncrypt', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    const eventEmmitted = fake.resolves(null);
-    aclStream.on('encrypt', eventEmmitted);
+    const eventEmitted = jest.fn().mockResolvedValue(null);
+    aclStream.on('encrypt', eventEmitted);
 
     aclStream.pushEncrypt('cid');
 
-    assert.calledOnceWithExactly(eventEmmitted, 'cid');
+    expect(eventEmitted).toHaveBeenCalledTimes(1);
+    expect(eventEmitted).toHaveBeenCalledWith('cid');
   });
 
   it('onSmpStk', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
-    const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
+    hci.startLeEncryption = jest.fn().mockResolvedValue(null);
 
-    aclStream._hci.startLeEncryption = fake.resolves(null);
+    const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
     aclStream.onSmpStk('stk');
 
-    assert.calledOnceWithExactly(aclStream._hci.startLeEncryption, handle, Buffer.from('0000000000000000', 'hex'), Buffer.from('0000', 'hex'), 'stk');
+    expect(hci.startLeEncryption).toHaveBeenCalledTimes(1);
+    expect(hci.startLeEncryption).toHaveBeenCalledWith(
+      handle, 
+      Buffer.from('0000000000000000', 'hex'), 
+      Buffer.from('0000', 'hex'), 
+      'stk'
+    );
   });
 
   it('onSmpFail', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    const eventEmmitted = fake.resolves(null);
-    aclStream.on('encryptFail', eventEmmitted);
+    const eventEmitted = jest.fn().mockResolvedValue(null);
+    aclStream.on('encryptFail', eventEmitted);
 
     aclStream.onSmpFail();
 
-    assert.calledOnceWithExactly(eventEmmitted);
+    expect(eventEmitted).toHaveBeenCalledTimes(1);
+    expect(eventEmitted).toHaveBeenCalledWith();
   });
 
   it('onSmpEnd', () => {
-    const hci = fake.resolves();
-    const handle = fake.resolves();
-    const localAddressType = fake.resolves();
-    const localAddress = fake.resolves();
-    const remoteAddressType = fake.resolves();
-    const remoteAddress = fake.resolves();
+    const hci = jest.fn().mockResolvedValue();
+    const handle = jest.fn().mockResolvedValue();
+    const localAddressType = jest.fn().mockResolvedValue();
+    const localAddress = jest.fn().mockResolvedValue();
+    const remoteAddressType = jest.fn().mockResolvedValue();
+    const remoteAddress = jest.fn().mockResolvedValue();
 
     const aclStream = new AclStream(hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress);
 
-    aclStream._smp.sendPairingRequest = fake.resolves(null);
-
     aclStream.onSmpEnd();
 
-    assert.calledThrice(aclStream._smp.removeListener);
-    assert.calledWith(aclStream._smp.removeListener, 'stk', match.any);
-    assert.calledWith(aclStream._smp.removeListener, 'fail', match.any);
-    assert.calledWith(aclStream._smp.removeListener, 'end', match.any);
+    expect(aclStream._smp.removeListener).toHaveBeenCalledTimes(3);
+    expect(aclStream._smp.removeListener).toHaveBeenCalledWith('stk', expect.any(Function));
+    expect(aclStream._smp.removeListener).toHaveBeenCalledWith('fail', expect.any(Function));
+    expect(aclStream._smp.removeListener).toHaveBeenCalledWith('end', expect.any(Function));
   });
-});
+});