fix more tests, remove all artificial waits

Author: frank06

lib/src/adapter/remote_adapter.dart

@@ -101,8 +101,9 @@ mixin _RemoteAdapter<T extends DataModelMixin<T>> on _SerializationAdapter<T> {
     );
 
     if (background) {
-      // ignore: unawaited_futures
-      future.then((_) => Future.value(_));
+      (() async {
+        await future;
+      })();
       return models;
     } else {
       return await future ?? <T>[];

test/_support/setup.dart

@@ -83,7 +83,6 @@ Future<void> tearDownFn() async {
   await core.storage.destroy();
 
   logging.clear();
-  await oneMs();
 }
 
 // utils
@@ -207,31 +206,4 @@ class DataStateNotifierTester<T> {
 extension SX<T> on DataStateNotifier<T> {
   DataStateNotifierTester tester({bool fireImmediately = false}) =>
       DataStateNotifierTester(this, fireImmediately: fireImmediately);
-
-  // Future<dynamic> expectDataState(dynamic model,
-  //     {dynamic isLoading,
-  //     dynamic exception,
-  //     bool fireImmediately = false}) async {
-  //   var m = isA<DataState<T>>();
-  //   if (model != null) {
-  //     if (model is List<(Function(T), dynamic)>) {
-  //       for (final (fn, arg) in model) {
-  //         m = m.having((s) => fn(s.model), 'model arg', arg);
-  //       }
-  //     } else {
-  //       m = m.having((s) => s.model, 'model', model);
-  //     }
-  //   }
-  //   if (isLoading != null) {
-  //     m = m.having((s) => s.isLoading, 'isLoading', isLoading);
-  //   }
-  //   if (exception != null) {
-  //     m = m.having((s) => s.exception, 'exception', exception);
-  //   }
-  //   final stream =
-  //       _streamWithInitialValueFor(this, fireImmediately: fireImmediately);
-  //   final result = expect(await stream.first, m);
-
-  //   return result;
-  // }
 }

test/model/relationship/has_many_test.dart

@@ -87,29 +87,24 @@ void main() async {
     final p2 = Person(name: 'b', age: 2).saveLocal();
 
     familia.persons.add(p1);
-    // await oneMs();
     expect(familia.persons.keys, {keyFor(p1)});
 
     verify(listener({p1})).called(1);
 
     expect(familia.persons.keys, {keyFor(p1)});
     familia.persons.add(p2);
-    // await oneMs();
 
     expect(familia.persons.keys, {keyFor(p1), keyFor(p2)});
     verify(listener({p1, p2})).called(1);
 
     familia.persons.remove(p1);
-    // await oneMs();
 
     verify(listener({p2})).called(1);
 
     familia.persons.add(p1);
-    // await oneMs();
 
     // NOTE: it is actually called once, I don't know what's wrong with this
     verify(listener({p1, p2})).called(1);
-    // await oneMs();
   });
 
   test('remove relationship', () async {

test/model/relationship/relationship_test.dart

@@ -1,5 +1,4 @@
 import 'package:flutter_data/flutter_data.dart';
-import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
 import '../../_support/book.dart';
@@ -260,21 +259,15 @@ void main() async {
         BookAuthor(id: 15, name: 'Lao Tzu', books: HasMany({book})).saveLocal();
     expect(author.books.first, book);
 
-    final listener = Listener<DataState<BookAuthor?>>();
     final notifier = container.bookAuthors.watchOneNotifier(author);
+    final tester = notifier.tester(fireImmediately: true);
 
-    final dispose = notifier.addListener(listener);
-    disposeFns.add(dispose);
-
-    verify(listener(DataState(author, isLoading: false))).called(1);
-    verifyNoMoreInteractions(listener);
+    await tester.expectDataState(author, isLoading: false);
 
     final author2 = author.copyWith(name: 'Steve-O').saveLocal();
 
-    await oneMs();
     expect(author.books.first, book);
-    verify(listener(DataState(author2, isLoading: false))).called(1);
-    verifyNoMoreInteractions(listener);
+    await tester.expectDataState(author2, isLoading: false);
 
     expect(author.books.first.originalAuthor!.value,
         equals(BookAuthor(id: 15, name: 'Steve-O', books: HasMany({book}))));

test/repository/remote_adapter_offline_test.dart

@@ -1,10 +1,7 @@
-@Timeout(Duration(minutes: 20))
-
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:flutter_data/flutter_data.dart';
-import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
 import '../_support/familia.dart';
@@ -97,13 +94,12 @@ void main() async {
         exception: isA<OfflineException>());
 
     // familia is remembered as failed to persist
-    // TODO fix: at location [0] is <1> instead of '1' (need # and ## again?)
-    // expect(
-    //     container.familia.offlineOperations
-    //         .only(DataRequestLabel('save', type: 'familia'))
-    //         .map((o) => o.label.id)
-    //         .toList(),
-    //     [familia.id]);
+    expect(
+        container.familia.offlineOperations
+            .only(DataRequestLabel('save', type: 'familia'))
+            .map((o) => o.label.id)
+            .toList(),
+        [familia.id]);
 
     // try with familia2 (tests it can work without ID)
     final familia2 = Familia(surname: 'Montewicz');
@@ -114,17 +110,15 @@ void main() async {
     }
 
     // now two familia failed to persist
-    // expect(
-    //     container.familia.offlineOperations
-    //         .only(DataRequestLabel('save', type: 'familia'))
-    //         .map((o) => o.label.id)
-    //         .toList(),
-    //     unorderedEquals([familia.id, familia2.id]));
+    expect(
+        container.familia.offlineOperations
+            .only(DataRequestLabel('save', type: 'familia'))
+            .map((o) => o.label.id)
+            .toList(),
+        unorderedEquals([familia.id, familia2.id]));
 
     // retry saving both
     await container.familia.offlineOperations.retry();
-    // await 1ms for each familia
-    await oneMs();
 
     // none of them could be saved upon retry
     expect(container.familia.offlineOperations.map((o) {
@@ -143,7 +137,6 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
 
     // familia2 failed on retry, operation still pending
     expect(container.familia.offlineOperations.map((o) => o.model),
@@ -158,7 +151,6 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
 
     // should be empty as all saves succeeded
     expect(container.familia.offlineOperations.map((o) => o.model), isEmpty);
@@ -173,7 +165,6 @@ void main() async {
     } catch (_) {
       // without onError, ignore exception
     }
-    await oneMs();
 
     // assert familia3 hasn't been persisted
     expect(
@@ -194,42 +185,32 @@ void main() async {
   });
 
   test('delete', () async {
-    final listener = Listener<DataState<List<Familia>?>?>();
     // listening to local changes is enough
     final notifier = container.familia.watchAllNotifier();
-
-    final dispose = notifier.addListener(listener);
-    disposeFns.add(dispose);
+    final tester = notifier.tester();
 
     final familia = Familia(id: '1', surname: 'Smith').saveLocal();
-    await oneMs();
 
     // should show up through watchAllNotifier
-    verify(listener(
-      argThat(isA<DataState>().having((s) => s.model, 'model', [familia])),
-    )).called(1);
+    await tester.expectDataState([familia]);
 
     // network issue deleting familia
     container.read(responseProvider.notifier).state = TestResponse((_) {
       throw SocketException('unreachable');
     });
 
     // delete familia and send offline exception to notifier
+    // NOTE: keep await, so that we give onError the chance to update the notifier
     await familia.delete(
       onError: (e, _, __) async {
-        await oneMs();
         expect(e, isA<OfflineException>());
         expect(e.error, isA<SocketException>());
         return null;
       },
     );
 
-    await oneMs();
-
     // verify the model in local storage has been deleted
-    verify(listener(
-      argThat(isA<DataState>().having((s) => s.model, 'model', isEmpty)),
-    )).called(2);
+    await tester.expectDataState(isEmpty);
 
     // familia is remembered as failed to persist
     expect(
@@ -240,7 +221,6 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
 
     // could not be deleted upon retry
     expect(
@@ -254,55 +234,43 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
 
     // now offline queue is empty
     expect(container.familia.offlineOperations, isEmpty);
   });
 
   test('save & delete combined', () async {
-    final listener = Listener<DataState<List<Familia>?>?>();
     // listening to local changes enough
     final notifier = container.familia.watchAllNotifier(remote: false);
-
-    final dispose = notifier.addListener(listener);
-    disposeFns.add(dispose);
+    final tester = notifier.tester();
 
     // setup familia
     final familia = Familia(id: '19', surname: 'Ko');
-    await oneMs();
 
     // network issues
     container.read(responseProvider.notifier).state = TestResponse((_) {
       throw SocketException('unreachable');
     });
 
-    // save...
+    // save
     await familia.save(
       headers: {'X-Override-Name': 'Johnson'},
       onError: (e, _, __) async {
-        await oneMs();
         notifier.updateWith(exception: e);
         return null;
       },
     );
 
-    await oneMs();
-
-    // ...and immediately delete
+    // immediately delete
     await familia.delete(
       onError: (e, _, __) async {
-        await oneMs();
         notifier.updateWith(exception: e);
         return null;
       },
     );
 
-    // assert it's an OfflineException, TWICE (one call per updateWith(e))
-    verify(listener(argThat(
-      isA<DataState>()
-          .having((s) => s.exception, 'exception', isA<OfflineException>()),
-    ))).called(1);
+    // assert it's an OfflineException
+    tester.expectDataState(isNotNull, exception: isA<OfflineException>());
 
     // should see the failed save queued
     expect(
@@ -331,16 +299,16 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
-    // same result...
+
+    // same result
     expect(container.familia.offlineOperations, hasLength(2));
 
     // change the response to success
     container.read(responseProvider.notifier).state = TestResponse.json('');
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
+
     // done
     expect(container.familia.offlineOperations, isEmpty);
   });
@@ -367,7 +335,6 @@ void main() async {
         return result;
       },
     );
-    await oneMs();
     // fails to go through
     expect(container.familia.offlineOperations, hasLength(1));
 
@@ -383,7 +350,7 @@ void main() async {
 
     // retry
     await container.familia.offlineOperations.retry();
-    await oneMs();
+
     // done
     expect(container.familia.offlineOperations, isEmpty);
   });

test/repository/remote_adapter_serialization_test.dart

@@ -1,5 +1,3 @@
-@Timeout(Duration(minutes: 20))
-
 import 'dart:convert';
 
 import 'package:flutter_data/flutter_data.dart';