@stoprocent/noble 1.9.2-16

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

@@ -0,0 +1,102 @@
+const should = require('should');
+const proxyquire = require('proxyquire').noCallThru();
+const { EventEmitter } = require('events');
+
+let chosenPlatform;
+let chosenRelease;
+const platform = () => chosenPlatform;
+const release = () => chosenRelease;
+
+class NobleMac {}
+
+class NobleWinrt {}
+
+const NobleMacImport = proxyquire('../../lib/mac/bindings', {
+  'node-gyp-build': () => ({ NobleMac })
+});
+
+const NobleWinrtImport = proxyquire('../../lib/win/bindings', {
+  'node-gyp-build': () => ({ NobleWinrt })
+});
+
+const WebSocket = require('../../lib/websocket/bindings');
+const NobleBindings = proxyquire('../../lib/distributed/bindings', {
+  ws: { Server: EventEmitter }
+});
+const HciNobleBindings = proxyquire('../../lib/hci-socket/bindings', {
+  './hci': EventEmitter
+});
+const resolver = proxyquire('../../lib/resolve-bindings', {
+  './distributed/bindings': NobleBindings,
+  './hci-socket/bindings': HciNobleBindings,
+  './mac/bindings': NobleMacImport,
+  './win/bindings': NobleWinrtImport,
+  os: { platform, release }
+});
+
+describe('resolve-bindings', () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    // Clone initial environment
+    process.env = Object.assign({}, OLD_ENV);
+  });
+
+  afterEach(() => {
+    // Restore initial environment
+    process.env = OLD_ENV;
+  });
+
+  it('web socket', () => {
+    process.env.NOBLE_WEBSOCKET = true;
+
+    const bindings = resolver({});
+    should(bindings).instanceof(WebSocket);
+  });
+
+  it('distributed', () => {
+    process.env.NOBLE_DISTRIBUTED = true;
+
+    const bindings = resolver({});
+    should(bindings).instanceof(NobleBindings);
+  });
+
+  it('mac', () => {
+    chosenPlatform = 'darwin';
+
+    const bindings = resolver({});
+    should(bindings).instanceof(NobleMac);
+  });
+
+  it('linux', () => {
+    chosenPlatform = 'linux';
+
+    const bindings = resolver({});
+    should(bindings).instanceof(HciNobleBindings);
+  });
+
+  it('freebsd', () => {
+    chosenPlatform = 'freebsd';
+
+    const bindings = resolver({});
+    should(bindings).instanceof(HciNobleBindings);
+  });
+
+  it('win32', () => {
+    chosenPlatform = 'win32';
+    chosenRelease = '10.0.22000';
+
+    const bindings = resolver({});
+    should(bindings).instanceof(NobleWinrt);
+  });
+
+  it('unknwon', () => {
+    chosenPlatform = 'unknwon';
+
+    try {
+      resolver({});
+    } catch (e) {
+      should(e).have.property('message', 'Unsupported platform');
+    }
+  });
+});

package/test/lib/service.test.js

@@ -0,0 +1,195 @@
+const should = require('should');
+const sinon = require('sinon');
+
+const { assert } = sinon;
+
+const Service = require('../../lib/service');
+
+describe('service', () => {
+  let mockNoble = null;
+  const mockPeripheralId = 'mock-peripheral-id';
+  const mockUuid = 'mock-uuid';
+
+  let service = null;
+
+  beforeEach(() => {
+    mockNoble = {};
+
+    service = new Service(mockNoble, mockPeripheralId, mockUuid);
+  });
+
+  it('should have a uuid', () => {
+    should(service.uuid).equal(mockUuid);
+  });
+
+  it('should lookup name and type by uuid', () => {
+    service = new Service(mockNoble, mockPeripheralId, '1800');
+
+    should(service.name).equal('Generic Access');
+    should(service.type).equal('org.bluetooth.service.generic_access');
+  });
+
+  describe('toString', () => {
+    it('should be uuid, name, type, includedServiceUuids', () => {
+      should(service.toString()).equal('{"uuid":"mock-uuid","name":null,"type":null,"includedServiceUuids":null}');
+    });
+  });
+
+  describe('discoverIncludedServices', () => {
+    beforeEach(() => {
+      mockNoble.discoverIncludedServices = sinon.spy();
+    });
+
+    afterEach(() => {
+      sinon.reset();
+    });
+
+    it('should delegate to noble', () => {
+      service.discoverIncludedServices();
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+    });
+
+    it('should delegate to noble, with uuids', () => {
+      const mockUuids = [];
+      service.discoverIncludedServices(mockUuids);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, mockUuids);
+    });
+
+    it('should callback', () => {
+      const callback = sinon.spy();
+
+      service.discoverIncludedServices(null, callback);
+      service.emit('includedServicesDiscover');
+
+      assert.calledOnceWithExactly(callback, null, undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, null);
+    });
+
+    it('should callback with data', () => {
+      const mockIncludedServiceUuids = ['service1'];
+      const callback = sinon.spy();
+
+      service.discoverIncludedServices(null, callback);
+      service.emit('includedServicesDiscover', mockIncludedServiceUuids);
+
+      assert.calledOnceWithExactly(callback, null, mockIncludedServiceUuids);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, null);
+    });
+  });
+
+  describe('discoverIncludedServicesAsync', () => {
+    beforeEach(() => {
+      mockNoble.discoverIncludedServices = sinon.spy();
+    });
+
+    afterEach(() => {
+      sinon.reset();
+    });
+
+    it('should delegate to noble', async () => {
+      const promise = service.discoverIncludedServicesAsync();
+      service.emit('includedServicesDiscover');
+
+      should(promise).resolvedWith(undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+    });
+
+    it('should delegate to noble, with uuids', async () => {
+      const mockUuids = [];
+      const promise = service.discoverIncludedServicesAsync(mockUuids);
+      service.emit('includedServicesDiscover');
+
+      should(promise).resolvedWith(undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, mockUuids);
+    });
+
+    it('should resolve with data', async () => {
+      const mockIncludedServiceUuids = ['service1'];
+
+      const promise = service.discoverIncludedServicesAsync();
+      service.emit('includedServicesDiscover', mockIncludedServiceUuids);
+
+      should(promise).resolvedWith(mockIncludedServiceUuids);
+      assert.calledOnceWithExactly(mockNoble.discoverIncludedServices, mockPeripheralId, mockUuid, undefined);
+    });
+  });
+
+  describe('discoverCharacteristics', () => {
+    beforeEach(() => {
+      mockNoble.discoverCharacteristics = sinon.spy();
+    });
+
+    afterEach(() => {
+      sinon.reset();
+    });
+
+    it('should delegate to noble', () => {
+      service.discoverCharacteristics();
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+    });
+
+    it('should delegate to noble, with uuids', () => {
+      const mockUuids = [];
+      service.discoverCharacteristics(mockUuids);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, mockUuids);
+    });
+
+    it('should callback', () => {
+      const callback = sinon.spy();
+
+      service.discoverCharacteristics(null, callback);
+      service.emit('characteristicsDiscover');
+
+      assert.calledOnceWithExactly(callback, null, undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, null);
+    });
+
+    it('should callback with data', () => {
+      const mockCharacteristics = [];
+      const callback = sinon.spy();
+
+      service.discoverCharacteristics(null, callback);
+      service.emit('characteristicsDiscover', mockCharacteristics);
+
+      assert.calledOnceWithExactly(callback, null, mockCharacteristics);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, null);
+    });
+  });
+
+  describe('discoverCharacteristicsAsync', () => {
+    beforeEach(() => {
+      mockNoble.discoverCharacteristics = sinon.spy();
+    });
+
+    afterEach(() => {
+      sinon.reset();
+    });
+
+    it('should delegate to noble', async () => {
+      const promise = service.discoverCharacteristicsAsync();
+      service.emit('characteristicsDiscover');
+
+      should(promise).resolvedWith(undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+    });
+
+    it('should delegate to noble, with uuids', async () => {
+      const mockUuids = [];
+      const promise = service.discoverCharacteristicsAsync(mockUuids);
+      service.emit('characteristicsDiscover');
+
+      should(promise).resolvedWith(undefined);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, mockUuids);
+    });
+
+    it('should resolve with data', async () => {
+      const mockCharacteristics = [];
+
+      const promise = service.discoverCharacteristicsAsync();
+      service.emit('characteristicsDiscover', mockCharacteristics);
+
+      should(promise).resolvedWith(mockCharacteristics);
+      assert.calledOnceWithExactly(mockNoble.discoverCharacteristics, mockPeripheralId, mockUuid, undefined);
+    });
+  });
+});

package/test/lib/webbluetooth/bindings.test.js

@@ -0,0 +1,190 @@
+const sinon = require('sinon');
+const should = require('should');
+
+const { assert } = sinon;
+
+const Bindings = require('../../../lib/webbluetooth/bindings');
+
+describe('webbluetooth bindings', () => {
+  let bindings;
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+
+    bindings = new Bindings();
+  });
+
+  afterEach(() => {
+    clock.restore();
+    sinon.reset();
+  });
+
+  it('constructor', () => {
+    should(bindings._ble).equal(null);
+    should(bindings._startScanCommand).equal(null);
+    should(bindings._peripherals).deepEqual({});
+  });
+
+  describe('init', () => {
+    it('should use ble arg', () => {
+      const errorCallback = sinon.spy();
+
+      bindings.on('error', errorCallback);
+      bindings.init({});
+
+      clock.tick(1);
+
+      assert.notCalled(errorCallback);
+    });
+  });
+
+  it('onClose - should emit stateChange', () => {
+    const callback = sinon.spy();
+
+    bindings.on('stateChange', callback);
+    bindings.onClose();
+
+    assert.calledOnceWithExactly(callback, 'poweredOff');
+  });
+
+  describe('startScanning', () => {
+    let scanStopCallback;
+    let discoverCallback;
+    let errorCallback;
+    let scanStartCallback;
+
+    let device;
+
+    beforeEach(() => {
+      device = {
+        id: 'id',
+        name: 'name',
+        services: ['1234', 'service9']
+      };
+
+      scanStopCallback = sinon.spy();
+      discoverCallback = sinon.spy();
+      errorCallback = sinon.spy();
+      scanStartCallback = sinon.spy();
+
+      bindings._ble = {
+        requestDevice: sinon.fake.resolves(device)
+      };
+
+      bindings.on('scanStop', scanStopCallback);
+      bindings.on('discover', discoverCallback);
+      bindings.on('error', errorCallback);
+      bindings.on('scanStart', scanStartCallback);
+    });
+
+    it('should emit discover with object options', async () => {
+      const options = { services: ['1234', '0x5678', 'service'] };
+      const allowDuplicates = true;
+
+      bindings.startScanning(options, allowDuplicates);
+
+      await clock.tickAsync(210);
+
+      assert.calledOnceWithExactly(bindings._ble.requestDevice, { filters: [{ services: [4660] }, { services: [22136] }, { services: ['service'] }] });
+      assert.calledOnceWithExactly(scanStopCallback, {});
+      assert.calledOnceWithExactly(discoverCallback, device.id, device.id, device.addressType, !device.paired, { localName: device.name }, undefined);
+      assert.notCalled(errorCallback);
+      assert.calledOnceWithExactly(scanStartCallback);
+
+      should(bindings._peripherals).deepEqual({
+        [device.id]: {
+          uuid: device.id,
+          address: device.id,
+          advertisement: { localName: device.name }, // advertisement,
+          device: device,
+          cachedServices: {},
+          localName: device.name,
+          serviceUuids: options.services
+        }
+      });
+    });
+
+    it('should emit discover with array options', async () => {
+      const options = ['1234', '0x5678', 'service'];
+      const allowDuplicates = false;
+
+      device.adData = {
+        rssi: 33
+      };
+
+      bindings.startScanning(options, allowDuplicates);
+
+      await clock.tickAsync(210);
+
+      assert.calledOnceWithExactly(bindings._ble.requestDevice, { filters: [{ services: [4660] }, { services: [22136] }, { services: ['service'] }] });
+      assert.calledOnceWithExactly(scanStopCallback, {});
+      assert.calledOnceWithExactly(discoverCallback, device.id, device.id, device.addressType, !device.paired, { localName: device.name }, 33);
+      assert.notCalled(errorCallback);
+      assert.calledOnceWithExactly(scanStartCallback);
+
+      should(bindings._peripherals).deepEqual({
+        [device.id]: {
+          uuid: device.id,
+          address: device.id,
+          advertisement: { localName: device.name }, // advertisement,
+          device: device,
+          cachedServices: {},
+          localName: device.name,
+          serviceUuids: [4660, 22136, 'service'],
+          rssi: 33
+        }
+      });
+    });
+
+    it('should not emit discover on null device', async () => {
+      const options = ['1234', '0x5678', 'service'];
+      const allowDuplicates = false;
+
+      bindings._ble.requestDevice = sinon.fake.resolves(null);
+
+      bindings.startScanning(options, allowDuplicates);
+
+      await clock.tickAsync(210);
+
+      assert.calledOnceWithExactly(bindings._ble.requestDevice, { filters: [{ services: [4660] }, { services: [22136] }, { services: ['service'] }] });
+      assert.calledOnceWithExactly(scanStopCallback, {});
+      assert.notCalled(discoverCallback);
+      assert.notCalled(errorCallback);
+      assert.calledOnceWithExactly(scanStartCallback);
+
+      should(bindings._peripherals).deepEqual({});
+    });
+
+    it('should emit error', async () => {
+      const options = ['1234', '0x5678', 'service'];
+      const allowDuplicates = false;
+
+      bindings._ble.requestDevice = sinon.fake.rejects(new Error('err'));
+
+      bindings.startScanning(options, allowDuplicates);
+
+      await clock.tickAsync(210);
+
+      assert.calledOnceWithExactly(bindings._ble.requestDevice, { filters: [{ services: [4660] }, { services: [22136] }, { services: ['service'] }] });
+      assert.calledOnceWithExactly(scanStopCallback, {});
+      assert.notCalled(discoverCallback);
+      assert.calledOnceWithMatch(errorCallback, sinon.match({ message: 'err' }));
+      assert.calledOnceWithExactly(scanStartCallback);
+
+      should(bindings._peripherals).deepEqual({});
+    });
+  });
+
+  it('stopScanning', () => {
+    const callback = sinon.spy();
+
+    bindings._startScanCommand = 'not_null';
+    bindings.on('scanStop', callback);
+
+    bindings.stopScanning();
+
+    assert.calledOnceWithExactly(callback);
+    should(bindings._startScanCommand).equal(null);
+  });
+});