tests for peripheral

Author: pawelByszewski

lib/src/_managers_for_classes.dart

@@ -39,7 +39,7 @@ abstract class ManagerForPeripheral {
     String transactionId,
   );
 
-  Future<void> requestMtu(
+  Future<int> requestMtu(
     Peripheral peripheral,
     int mtu,
     String transactionId,

lib/src/internal_ble_manager.dart

@@ -174,7 +174,7 @@ class InternalBleManager
   }
 
   @override
-  Future<void> requestMtu(
+  Future<int> requestMtu(
       Peripheral peripheral, int mtu, String transactionId) {
     return _bleLib.requestMtu(peripheral, mtu, transactionId);
   }

test/peripheral_test.dart

@@ -1,5 +1,6 @@
 
-import 'package:flutter/services.dart';
+import 'dart:typed_data';
+
 import 'package:flutter_ble_lib/flutter_ble_lib.dart';
 import 'package:flutter_ble_lib/src/_managers_for_classes.dart';
 import 'package:flutter_ble_lib/src/util/_transaction_id_generator.dart';
@@ -10,6 +11,9 @@ class ManagerForPeripheralMock extends Mock implements ManagerForPeripheral {}
 class ServiceMock extends Mock implements Service {}
 class CharacteristicMock extends Mock implements Characteristic {}
 class TransactionIdGeneratorMock extends Mock implements TransactionIdGenerator {}
+class CharacteristicWithValueMock extends Mock implements CharacteristicWithValue {}
+class DescriptorMock extends Mock implements Descriptor {}
+class DescriptorWithValueMock extends Mock implements DescriptorWithValue {}
 
 void main() {
 
@@ -30,7 +34,7 @@ void main() {
     peripheral = Peripheral.fromJson(json, managerForPeripheral, transactionIdGenerator: transactionIdGeneratorMock);
   });
 
-  group("Connect", () {
+  group("Connection", () {
     test('should pass defaut values to manager', () {
       //when
       peripheral.connect();
@@ -69,9 +73,7 @@ void main() {
           timeout: timeout
       ));
     });
-  });
 
-  group("Observe connection state", () {
     test("should emit on every connection state change", () {
       //given
       var states = [
@@ -89,7 +91,7 @@ void main() {
       expect(connectionStateStream, emitsInOrder(states));
     });
 
-    test("should pass arguments to manager", () {
+    test("should pass arguments to manager for observing connection state", () {
       //given
       var emitCurrentValue = true;
       var completeOnDisconnect = true;
@@ -100,9 +102,15 @@ void main() {
       //then
       verify(managerForPeripheral.observePeripheralConnectionState(PERIPHERAL_ID, emitCurrentValue, completeOnDisconnect));
     });
-  });
 
-  group("Connection checking", () {
+    test('should call disconnect on manager with valid arguments', () {
+      //when
+      peripheral.disconnectOrCancelConnection();
+
+      //then
+      verify(managerForPeripheral.disconnectOrCancelPeripheralConnection(PERIPHERAL_ID));
+    });
+
     [true, false].forEach((isConnected) {
       test("returns isConneted information based on $isConnected returned by manager", () async {
         //given
@@ -172,6 +180,102 @@ void main() {
       //then
       expect(fetchedCharacteristic, characteristics);
     });
+
+    test("schould return value of characteristic", () async {
+      //given
+      CharacteristicWithValue mockedCharacteristicWithValue  = CharacteristicWithValueMock();
+      var transactionId = "t1";
+      when(managerForPeripheral.readCharacteristicForDevice(any, any, any, transactionId))
+        .thenAnswer((_) => Future.value(mockedCharacteristicWithValue));
+
+      //when
+      CharacteristicWithValue characteristicWithValue = await peripheral.readCharacteristic('s1', 'c1', transactionId: transactionId);
+
+      //then
+      expect(characteristicWithValue, mockedCharacteristicWithValue);
+    });
+
+    test("should use autogenerated transactionId during reading operation", () async {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+      await peripheral.readCharacteristic('s1', 'c1');
+      await peripheral.readCharacteristic('s1', 'c1');
+
+      //then
+      verify(managerForPeripheral.readCharacteristicForDevice(any, any, any, '4'));
+      verify(managerForPeripheral.readCharacteristicForDevice(any, any, any, '9'));
+    });
+
+    test("should write value to characteristic", () async {
+      //given
+      CharacteristicWithValue mockedCharacteristicWithValue  = CharacteristicWithValueMock();
+      const serviceUuid = 's1';
+      const characteristicUuid = 'c1';
+      const transactionId = 't1';
+      Uint8List value = Uint8List.fromList([1, 4, 9]);
+      const withResponse = false;
+
+      when(managerForPeripheral.writeCharacteristicForDevice(any, serviceUuid, characteristicUuid, value, withResponse, transactionId))
+          .thenAnswer((_) => Future.value(mockedCharacteristicWithValue));
+
+      //when
+      CharacteristicWithValue characteristicWithValue = await peripheral.writeCharacteristic(serviceUuid, characteristicUuid, value, withResponse, transactionId: transactionId);
+
+      //then
+      expect(characteristicWithValue, mockedCharacteristicWithValue);
+    });
+
+    test("should use autogenerated transactionId during writing operation", () async {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+      await peripheral.writeCharacteristic('s1', 'c1', Uint8List.fromList([1]), false);
+      await peripheral.writeCharacteristic('s1', 'c1', Uint8List.fromList([1]), false);
+
+      //then
+      verify(managerForPeripheral.writeCharacteristicForDevice(any, any, any, any, any, '4'));
+      verify(managerForPeripheral.writeCharacteristicForDevice(any, any, any, any, any, '9'));
+    });
+
+    test("should return values of monitored characteristic", () {
+      //given
+      var emittedValues = [
+        CharacteristicWithValueMock(),
+        CharacteristicWithValueMock(),
+        CharacteristicWithValueMock()
+      ];
+      const serviceUuid = 's1';
+      const characteristicUuid = 'c1';
+      const transactionId = 't1';
+      when(managerForPeripheral.monitorCharacteristicForDevice(any, serviceUuid, characteristicUuid, transactionId))
+          .thenAnswer((_) => Stream.fromIterable(emittedValues));
+
+      //when
+      Stream<CharacteristicWithValue> characteristicsStream =  peripheral.monitorCharacteristic(serviceUuid, characteristicUuid, transactionId: transactionId);
+
+      //then
+      expect(characteristicsStream, emitsInOrder(emittedValues));
+    });
+
+    test("should use autogenerated transactionId for monitoring operation", () {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+     peripheral.monitorCharacteristic('s1', 'c1');
+     peripheral.monitorCharacteristic('s1', 'c1');
+
+      //then
+      verify(managerForPeripheral.monitorCharacteristicForDevice(any, any, any, '4'));
+      verify(managerForPeripheral.monitorCharacteristicForDevice(any, any, any, '9'));
+    });
+
   });
 
   group("Rssi", () {
@@ -204,4 +308,114 @@ void main() {
     });
   });
 
+  group("MTU", () {
+    test("returns negotiated MTU", () async {
+      //given
+      const requestedMtu = 23;
+      const negotiatedMtu = 135;
+      when(managerForPeripheral.requestMtu(any, requestedMtu, any)).thenAnswer((_) => Future.value(negotiatedMtu));
+
+      //when
+      int obtainedMtu = await peripheral.requestMtu(requestedMtu);
+
+      //then
+      expect(negotiatedMtu, obtainedMtu);
+    });
+
+    test("use generated transactionId", () async {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+      await peripheral.requestMtu(23);
+      await peripheral.requestMtu(45);
+
+      //then
+      verify(managerForPeripheral.requestMtu(any, any, '4'));
+      verify(managerForPeripheral.requestMtu(any, any, '9'));
+    });
+  });
+
+  group("Descriptor", () {
+    test("should return desriptors of characteristic", () async {
+      //given
+      List<Descriptor> descriptors = [DescriptorMock(), DescriptorMock()];
+      const serviceUuid = "123uuid";
+      const characteristicUuid = "c1";
+      when(managerForPeripheral.descriptorsForPeripheral(any, serviceUuid, characteristicUuid)).thenAnswer((_) => Future.value(descriptors));
+
+      //when
+      List<Descriptor> fetchedDescriptors = await peripheral.descriptorsForCharacteristic(serviceUuid, characteristicUuid);
+
+      //then
+      expect(fetchedDescriptors, descriptors);
+    });
+
+    test("should return Descriptor value", () async {
+      //given
+      DescriptorWithValue descriptorWithValue  = DescriptorWithValueMock();
+      const serviceUuid = "123uuid";
+      const characteristicUuid = "c1";
+      const descriptorUuid = "c1";
+      const transactionId = "t1";
+      when(managerForPeripheral.readDescriptorForPeripheral(any, serviceUuid, characteristicUuid, descriptorUuid, transactionId))
+          .thenAnswer((_) => Future.value(descriptorWithValue));
+
+      //when
+      DescriptorWithValueMock obtainedDescriptorWithValue = await peripheral.readDescriptor(serviceUuid, characteristicUuid, descriptorUuid, transactionId: transactionId);
+
+      //then
+      expect(obtainedDescriptorWithValue, descriptorWithValue);
+    });
+
+    test("should use autogenerated transactionId during reading operation", () async {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+      await peripheral.readDescriptor('s1', 'c1', 'd1');
+      await peripheral.readDescriptor('s1', 'c1', 'd1');
+
+      //then
+      verify(managerForPeripheral.readDescriptorForPeripheral(any, any, any, any, '4'));
+      verify(managerForPeripheral.readDescriptorForPeripheral(any, any, any, any, '9'));
+    });
+
+    test("should write value to descriptor", () async {
+      //given
+      DescriptorWithValue descriptorWithValue  = DescriptorWithValueMock();
+      const serviceUuid = "123uuid";
+      const characteristicUuid = "c1";
+      const descriptorUuid = "c1";
+      const transactionId = "t1";
+      Uint8List value = Uint8List.fromList([1, 4, 9]);
+
+      when(managerForPeripheral.writeDescriptorForPeripheral(any, serviceUuid, characteristicUuid, descriptorUuid, value, transactionId))
+          .thenAnswer((_) => Future.value(descriptorWithValue));
+
+      //when
+      DescriptorWithValue obtainedDescriptorWithValue = await peripheral.writeDescriptor(serviceUuid, characteristicUuid, descriptorUuid, value, transactionId: transactionId);
+
+      //then
+      expect(obtainedDescriptorWithValue, descriptorWithValue);
+    });
+
+    test("should use autogenerated transactionId during writing operation", () async {
+      //given
+      var ids = ["4", "9"];
+      when(transactionIdGeneratorMock.getNextId()).thenAnswer((_) => ids.removeAt(0));
+
+      //when
+      await peripheral.writeDescriptor('s1', 'c1', 'd1', Uint8List.fromList([1]));
+      await peripheral.writeDescriptor('s1', 'c1', 'd1', Uint8List.fromList([1]));
+
+      //then
+      verify(managerForPeripheral.writeDescriptorForPeripheral(any, any, any, any, any, '4'));
+      verify(managerForPeripheral.writeDescriptorForPeripheral(any, any, any, any, any, '9'));
+    });
+  });
+
+
 }