omi/app/test/unit/device_connection_find_pattern_test.dart at main · ghzhost/omi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import 'dart:async';

import 'package:fake_async/fake_async.dart';
import 'package:flutter_test/flutter_test.dart';

import 'package:omi/backend/schema/bt_device/bt_device.dart';
import 'package:omi/services/devices/connectors/omi_connection.dart';
import 'package:omi/services/devices/models.dart';
import 'package:omi/services/devices/transports/device_transport.dart';

class _RecordingTransport extends DeviceTransport {
  final List<(String, String, List<int>)> writes = [];
  int writeAttempts = 0;
  int? failOnAttempt;
  bool connected = true;
  Completer<void>? writeBlocker;

  @override
  String get deviceId => 'omi-1';

  @override
  Future<void> connect() async {}

  @override
  Future<void> disconnect() async {}

  @override
  Future<bool> isConnected() async => connected;

  @override
  Future<bool> ping() async => connected;

  @override
  Stream<List<int>> getCharacteristicStream(String serviceUuid, String characteristicUuid) => const Stream.empty();

  @override
  Future<List<int>> readCharacteristic(String serviceUuid, String characteristicUuid) async => [];

  @override
  Future<void> writeCharacteristic(String serviceUuid, String characteristicUuid, List<int> data) async {
    writeAttempts++;
    await writeBlocker?.future;
    if (writeAttempts == failOnAttempt) throw StateError('write failed');
    writes.add((serviceUuid, characteristicUuid, List<int>.from(data)));
  }

  @override
  Stream<DeviceTransportState> get connectionStateStream => const Stream.empty();

  @override
  Future<void> dispose() async {}
}

OmiDeviceConnection _connection(_RecordingTransport transport) =>
    OmiDeviceConnection(BtDevice(id: transport.deviceId, name: 'Omi', type: DeviceType.omi, rssi: -40), transport);

void main() {
  test('find-device pattern sends three distinct long haptic pulses', () {
    fakeAsync((async) {
      final transport = _RecordingTransport();
      bool? result;

      _connection(transport).playFindDevicePattern().then((value) => result = value);
      async.flushMicrotasks();

      expect(transport.writes, hasLength(1));
      expect(transport.writes.single.$1, speakerDataStreamServiceUuid);
      expect(transport.writes.single.$2, speakerDataStreamCharacteristicUuid);
      expect(transport.writes.single.$3, [3]);

      async.elapse(const Duration(milliseconds: 750));
      async.flushMicrotasks();
      expect(transport.writes, hasLength(2));

      async.elapse(const Duration(milliseconds: 750));
      async.flushMicrotasks();

      expect(result, isTrue);
      expect(transport.writes, hasLength(3));
      for (final write in transport.writes) {
        expect(write.$1, speakerDataStreamServiceUuid);
        expect(write.$2, speakerDataStreamCharacteristicUuid);
        expect(write.$3, [3]);
      }
    });
  });

  test('find-device pattern stops and reports failure when a pulse cannot be sent', () {
    fakeAsync((async) {
      final transport = _RecordingTransport()..failOnAttempt = 2;
      bool? result;

      _connection(transport).playFindDevicePattern().then((value) => result = value);
      async.flushMicrotasks();
      async.elapse(const Duration(milliseconds: 750));
      async.flushMicrotasks();

      expect(result, isFalse);
      expect(transport.writeAttempts, 2);
      expect(transport.writes, hasLength(1));

      async.elapse(const Duration(seconds: 2));
      expect(transport.writeAttempts, 2);
    });
  });

  test('find-device pattern reports failure without writing when disconnected', () {
    fakeAsync((async) {
      final transport = _RecordingTransport()..connected = false;
      bool? result;

      _connection(transport).playFindDevicePattern().then((value) => result = value);
      async.flushMicrotasks();

      expect(result, isFalse);
      expect(transport.writeAttempts, 0);
      expect(transport.writes, isEmpty);
    });
  });

  test('find-device pattern times out a stalled haptic write', () {
    fakeAsync((async) {
      final blocker = Completer<void>();
      final transport = _RecordingTransport()..writeBlocker = blocker;
      bool? result;

      _connection(transport).playFindDevicePattern().then((value) => result = value);
      async.flushMicrotasks();
      expect(transport.writeAttempts, 1);

      async.elapse(const Duration(seconds: 5));
      async.flushMicrotasks();

      expect(result, isFalse);
      expect(transport.writeAttempts, 1);
      expect(transport.writes, isEmpty);

      blocker.complete();
      async.flushMicrotasks();
      expect(transport.writeAttempts, 1);
    });
  });
}