@stoprocent/noble 1.19.0 → 2.0.0

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

@@ -1,190 +0,0 @@
-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,
-          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,
-          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);
-  });
-});

package/test/lib/websocket/bindings.test.js

@@ -1,456 +0,0 @@
-const sinon = require('sinon');
-const should = require('should');
-const proxyquire = require('proxyquire').noCallThru();
-
-const { assert } = sinon;
-
-describe('webbluetooth bindings', () => {
-  const FakeWebsocket = sinon.spy();
-
-  const Bindings = proxyquire('../../../lib/websocket/bindings', {
-    ws: FakeWebsocket
-  });
-
-  let bindings;
-
-  beforeEach(() => {
-    FakeWebsocket.prototype.on = sinon.spy();
-
-    bindings = new Bindings();
-  });
-
-  afterEach(() => {
-    sinon.reset();
-  });
-
-  it('constructor', () => {
-    assert.calledOnceWithExactly(FakeWebsocket, 'ws://localhost:2846');
-    assert.callCount(bindings._ws.on, 4);
-    assert.calledWithMatch(bindings._ws.on, 'open', sinon.match.func);
-    assert.calledWithMatch(bindings._ws.on, 'close', sinon.match.func);
-    assert.calledWithMatch(bindings._ws.on, 'error', sinon.match.func);
-    assert.calledWithMatch(bindings._ws.on, 'message', sinon.match.func);
-  });
-
-  it('onClose - should emit stateChange', () => {
-    const callback = sinon.spy();
-
-    bindings.on('stateChange', callback);
-    bindings._onClose();
-
-    assert.calledOnceWithExactly(callback, 'poweredOff');
-  });
-
-  describe('_onMessage', () => {
-    const mainEvent = {
-      peripheralUuid: 'peripheralUuid',
-      address: 'address',
-      addressType: 'addressType',
-      connectable: 'connectable',
-      advertisement: {
-        localName: 'localName',
-        txPowerLevel: 34,
-        serviceUuids: 'ad.serviceUuids',
-        manufacturerData: null,
-        serviceData: null
-      },
-      rssi: 'rssi',
-      serviceUuids: 'serviceUuids',
-      serviceUuid: 'serviceUuid',
-      includedServiceUuids: 'includedServiceUuids',
-      characteristics: 'characteristics',
-      characteristicUuid: 'characteristicUuid',
-      isNotification: 'isNotification',
-      state: 'state',
-      descriptors: 'descriptors',
-      descriptorUuid: 'descriptorUuid',
-      handle: 'handle'
-    };
-
-    [
-      { type: 'stateChange', event: ['stateChange', mainEvent.state] },
-      { type: 'discover', event: ['discover', mainEvent.peripheralUuid, mainEvent.address, mainEvent.addressType, mainEvent.connectable, mainEvent.advertisement, mainEvent.rssi] },
-      { type: 'connect', event: ['connect', mainEvent.peripheralUuid] },
-      { type: 'disconnect', event: ['disconnect', mainEvent.peripheralUuid] },
-      { type: 'rssiUpdate', event: ['rssiUpdate', mainEvent.peripheralUuid, mainEvent.rssi] },
-      { type: 'servicesDiscover', event: ['servicesDiscover', mainEvent.peripheralUuid, mainEvent.serviceUuids] },
-      { type: 'includedServicesDiscover', event: ['includedServicesDiscover', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.includedServiceUuids] },
-      { type: 'characteristicsDiscover', event: ['characteristicsDiscover', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristics] },
-      { type: 'read', event: ['read', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, null, mainEvent.isNotification] },
-      { type: 'write', event: ['write', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid] },
-      { type: 'broadcast', event: ['broadcast', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, mainEvent.state] },
-      { type: 'notify', event: ['notify', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, mainEvent.state] },
-      { type: 'descriptorsDiscover', event: ['descriptorsDiscover', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, mainEvent.descriptors] },
-      { type: 'valueRead', event: ['valueRead', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, mainEvent.descriptorUuid, null] },
-      { type: 'valueWrite', event: ['valueWrite', mainEvent.peripheralUuid, mainEvent.serviceUuid, mainEvent.characteristicUuid, mainEvent.descriptorUuid] },
-      { type: 'handleRead', event: ['handleRead', mainEvent.peripheralUuid, mainEvent.handle, null] },
-      { type: 'handleWrite', event: ['handleWrite', mainEvent.peripheralUuid, mainEvent.handle] },
-      { type: 'handleNotify', event: ['handleNotify', mainEvent.peripheralUuid, mainEvent.handle, null] }
-    ].forEach(args => {
-      const { type, event } = args;
-      it(`should emit ${type}`, () => {
-        bindings.emit = sinon.spy();
-
-        const eventMsg = Object.assign({ type }, mainEvent);
-        bindings._onMessage(eventMsg);
-
-        assert.calledOnceWithExactly(bindings.emit, ...event);
-      });
-    });
-  });
-
-  describe('sendCommand', () => {
-    it('should not callback without error', () => {
-      const errorCallback = sinon.spy();
-
-      bindings._ws.send = sinon.spy();
-      bindings._sendCommand({ command: 3 }, errorCallback);
-
-      bindings._ws.send.callArgWith(1, null);
-
-      assert.calledOnceWithMatch(bindings._ws.send, '{"command":3}', sinon.match.func);
-      assert.notCalled(errorCallback);
-    });
-
-    it('should callback error', () => {
-      const errorCallback = sinon.spy();
-
-      bindings._ws.send = sinon.spy();
-      bindings._sendCommand({ command: 3 }, errorCallback);
-
-      bindings._ws.send.callArgWith(1, 'error');
-
-      assert.calledOnceWithMatch(bindings._ws.send, '{"command":3}', sinon.match.func);
-      assert.calledOnceWithExactly(errorCallback, 'error');
-    });
-
-    it('should not callback error as it is missing', () => {
-      bindings._ws.send = sinon.spy();
-      bindings._sendCommand({ command: 3 });
-
-      bindings._ws.send.callArgWith(1, 'error');
-
-      assert.calledOnceWithMatch(bindings._ws.send, '{"command":3}', sinon.match.func);
-    });
-  });
-
-  it('startScanning - should emit scanStart', () => {
-    const callback = sinon.spy();
-    const serviceUuids = ['service'];
-    const allowDuplicates = true;
-
-    bindings._sendCommand = sinon.spy();
-    bindings.on('scanStart', callback);
-    bindings.startScanning(serviceUuids, allowDuplicates);
-
-    const startCommand = {
-      action: 'startScanning',
-      serviceUuids,
-      allowDuplicates
-    };
-    assert.calledOnceWithExactly(callback);
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-    should(bindings._startScanCommand).deepEqual(startCommand);
-  });
-
-  it('stopScanning - should emit scanStop', () => {
-    const callback = sinon.spy();
-
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.on('scanStop', callback);
-    bindings.stopScanning();
-
-    const startCommand = {
-      action: 'stopScanning'
-    };
-    assert.calledOnceWithExactly(callback);
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-    should(bindings._startScanCommand).equal(null);
-  });
-
-  it('connect - should send connect command', () => {
-    const deviceUuid = 'deviceUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.connect(deviceUuid);
-
-    const startCommand = {
-      action: 'connect',
-      peripheralUuid: 'uuid'
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('disconnect - should send disconnect command', () => {
-    const deviceUuid = 'deviceUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.disconnect(deviceUuid);
-
-    const startCommand = {
-      action: 'disconnect',
-      peripheralUuid: 'uuid'
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('updateRssi - should send updateRssi command', () => {
-    const deviceUuid = 'deviceUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.updateRssi(deviceUuid);
-
-    const startCommand = {
-      action: 'updateRssi',
-      peripheralUuid: 'uuid'
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('discoverServices - should send discoverServices command', () => {
-    const deviceUuid = 'deviceUuid';
-    const uuids = 'uuids';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.discoverServices(deviceUuid, uuids);
-
-    const startCommand = {
-      action: 'discoverServices',
-      peripheralUuid: 'uuid',
-      uuids
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('discoverIncludedServices - should send discoverIncludedServices command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const serviceUuids = 'serviceUuids';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.discoverIncludedServices(deviceUuid, serviceUuid, serviceUuids);
-
-    const startCommand = {
-      action: 'discoverIncludedServices',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      serviceUuids
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('discoverCharacteristics - should send discoverIncludedServices command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuids = 'characteristicUuids';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.discoverCharacteristics(deviceUuid, serviceUuid, characteristicUuids);
-
-    const startCommand = {
-      action: 'discoverCharacteristics',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuids
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('read - should send read command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.read(deviceUuid, serviceUuid, characteristicUuid);
-
-    const startCommand = {
-      action: 'read',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('write - should send write command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-    const data = Buffer.from([0x34, 0x12]);
-    const withoutResponse = true;
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.write(deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse);
-
-    const startCommand = {
-      action: 'write',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid,
-      data: '3412',
-      withoutResponse
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('broadcast - should send broadcast command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-    const broadcast = true;
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.broadcast(deviceUuid, serviceUuid, characteristicUuid, broadcast);
-
-    const startCommand = {
-      action: 'broadcast',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid,
-      broadcast
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('notify - should send notify command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-    const notify = true;
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.notify(deviceUuid, serviceUuid, characteristicUuid, notify);
-
-    const startCommand = {
-      action: 'notify',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid,
-      notify
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('discoverDescriptors - should send discoverDescriptors command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.discoverDescriptors(deviceUuid, serviceUuid, characteristicUuid);
-
-    const startCommand = {
-      action: 'discoverDescriptors',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('readValue - should send readValue command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-    const descriptorUuid = 'descriptorUuid';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.readValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid);
-
-    const startCommand = {
-      action: 'readValue',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid,
-      descriptorUuid
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('writeValue - should send writeValue command', () => {
-    const deviceUuid = 'deviceUuid';
-    const serviceUuid = 'serviceUuid';
-    const characteristicUuid = 'characteristicUuid';
-    const descriptorUuid = 'descriptorUuid';
-    const data = Buffer.from([0x34, 0x12]);
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.writeValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
-
-    const startCommand = {
-      action: 'writeValue',
-      peripheralUuid: 'uuid',
-      serviceUuid,
-      characteristicUuid,
-      descriptorUuid,
-      data: '3412'
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('readHandle - should send readHandle command', () => {
-    const deviceUuid = 'deviceUuid';
-    const handle = 'handle';
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.readHandle(deviceUuid, handle);
-
-    const startCommand = {
-      action: 'readHandle',
-      peripheralUuid: 'uuid',
-      handle
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-
-  it('writeHandle - should send writeHandle command', () => {
-    const deviceUuid = 'deviceUuid';
-    const handle = 'handle';
-    const data = Buffer.from([0x34, 0x12]);
-    const withoutResponse = true;
-
-    bindings._peripherals[deviceUuid] = { uuid: 'uuid' };
-    bindings._startScanCommand = 'command';
-    bindings._sendCommand = sinon.spy();
-    bindings.writeHandle(deviceUuid, handle, data, withoutResponse);
-
-    const startCommand = {
-      action: 'writeHandle',
-      peripheralUuid: 'uuid',
-      handle,
-      data: '3412',
-      withoutResponse
-    };
-    assert.calledOnceWithExactly(bindings._sendCommand, startCommand);
-  });
-});

package/with-bindings.js

@@ -1,5 +0,0 @@
-const Noble = require('./lib/noble');
-
-module.exports = function (bindings) {
-  return new Noble(bindings);
-};

package/with-custom-binding.js

@@ -1,6 +0,0 @@
-module.exports = function (options) {
-  const Noble = require('./lib/noble');
-  const bindings = require('./lib/resolve-bindings')(options);
-
-  return new Noble(bindings);
-};