done test

Author: hoc081098

test/disposebag_test.dart

@@ -1,48 +1,15 @@
 import 'dart:async';
 
 import 'package:disposebag/disposebag.dart';
-
-// import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
+import 'mocks.dart';
+
 Stream<int> _getPeriodicStream() =>
     Stream.periodic(const Duration(milliseconds: 100), (i) => i).take(10);
 
 const _maxCount = 5;
 
-class MockDisposeBag /*extends Mock*/ implements DisposeBag {
-  var _disposeCount = 0;
-
-  @override
-  dynamic noSuchMethod(Invocation invocation) {
-    if (invocation.memberName == #dispose) {
-      ++_disposeCount;
-      return Future.value(true);
-    }
-    return super.noSuchMethod(invocation);
-  }
-
-  void verifyCalledDispose(int expected) => expect(_disposeCount, expected);
-}
-
-class MockSink /*extends Mock*/ implements Sink<int> {
-  @override
-  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-
-  @override
-  Future<void> close() async {}
-}
-
-class MockStreamSubscription /*extends Mock*/
-    implements
-        StreamSubscription<int> {
-  @override
-  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-
-  @override
-  Future<void> cancel() async {}
-}
-
 void main() {
   group('DisposeBag', () {
     group('DisposeBag.add', () {
@@ -101,9 +68,9 @@ void main() {
         await bag.add(controller);
         await bag.dispose();
 
-        /*verify(sink.close()).called(1);*/ //TODO
+        expect(sink.call, const MethodCall('close'));
         expect(controller.isClosed, true);
-      }, skip: true);
+      });
 
       test('DisposeBag.add.sink.isDisposed', () async {
         final controller = StreamController<int>()..stream.listen(null);
@@ -376,26 +343,24 @@ void main() {
       final disposeBag = DisposeBag();
       final mockStreamSubscription = MockStreamSubscription();
 
-      /*when(mockStreamSubscription.cancel()).thenAnswer(
-        (realInvocation) async => throw Exception(),
-      );*/ //TODO
+      mockStreamSubscription.whenCancel =
+          () => Future.error(Exception());
 
       await disposeBag.add(mockStreamSubscription);
       expect(await disposeBag.dispose(), false);
       expect(disposeBag.isDisposed, false);
-    }, skip: true);
+    });
 
     test('DisposeBag.clear.failed', () async {
       final disposeBag = DisposeBag();
       final mockStreamSubscription = MockStreamSubscription();
 
-      /*when(mockStreamSubscription.cancel()).thenAnswer(
-        (realInvocation) async => throw Exception(),
-      );*/ //TODO
+      mockStreamSubscription.whenCancel =
+          () => Future.error(Exception());
 
       await disposeBag.add(mockStreamSubscription);
       expect(await disposeBag.clear(), false);
-    }, skip: true);
+    });
 
     test('issue #2', () async {
       final bag = DisposeBag();
@@ -420,21 +385,21 @@ void main() {
   });
 
   group('Extensions', () {
-    late DisposeBag bag;
+    late MockDisposeBag bag;
 
     setUp(() => bag = MockDisposeBag());
 
     test('StreamSubscription.disposedBy', () {
       final subscription = Stream.value(1).listen(null);
       subscription.disposedBy(bag);
-      /*verify(bag.add(subscription)).called(1);*/ //TODO
-    }, skip: true);
+      expect(bag.call, MethodCall('add', subscription));
+    });
 
     test('Sink.disposedBy', () {
       final controller = StreamController<void>();
       controller.disposedBy(bag);
-      /*verify(bag.add(controller)).called(1);*/ //TODO
-    }, skip: true);
+      expect(bag.call, MethodCall('add', controller));
+    });
 
     test('Iterable<StreamSubscription>.disposedBy', () {
       final subscription1 = Stream.value(1).listen(null);
@@ -443,8 +408,8 @@ void main() {
       final subscriptions = [subscription1, subscription2];
       subscriptions.disposedBy(bag);
 
-      /*verify(bag.addAll(subscriptions)).called(1);*/ //TODO
-    }, skip: true);
+      expect(bag.call, MethodCall('addAll', subscriptions));
+    });
 
     test('Iterable<Sink>.disposedBy', () {
       final controller1 = StreamController<void>();
@@ -453,7 +418,7 @@ void main() {
       final sinks = [controller1, controller2];
       sinks.disposedBy(bag);
 
-      /*verify(bag.addAll(sinks)).called(1);*/ //TODO
-    }, skip: true);
+      expect(bag.call, MethodCall('addAll', sinks));
+    });
   });
 }

test/mocks.dart

@@ -0,0 +1,85 @@
+import 'dart:async';
+
+import 'package:disposebag/disposebag.dart';
+import 'package:meta/meta.dart';
+
+/// An command object representing the invocation of a named method.
+@immutable
+class MethodCall {
+  /// Creates a [MethodCall] representing the invocation of [method] with the
+  /// specified [arguments].
+  const MethodCall(this.method, [this.arguments]);
+
+  /// The name of the method to be called.
+  final String method;
+
+  /// The arguments for the method.
+  ///
+  /// Must be a valid value for the [MethodCodec] used.
+  final dynamic arguments;
+
+  @override
+  String toString() => 'MethodCall{method: $method, arguments: $arguments}';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is MethodCall &&
+          runtimeType == other.runtimeType &&
+          method == other.method &&
+          arguments == other.arguments;
+
+  @override
+  int get hashCode => method.hashCode ^ arguments.hashCode;
+}
+
+mixin MethodCallsMixin on Object {
+  final trueFuture = Future.value(true);
+
+  final calls = <MethodCall>[];
+
+  MethodCall get call => calls.single;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class MockDisposeBag with MethodCallsMixin implements DisposeBag {
+  @override
+  Future<bool> add(disposable) {
+    calls.add(MethodCall('add', disposable));
+    return trueFuture;
+  }
+
+  @override
+  Future<bool> addAll(Iterable disposables) {
+    calls.add(MethodCall('addAll', disposables));
+    return trueFuture;
+  }
+
+  @override
+  Future<bool> dispose() {
+    calls.add(const MethodCall('dispose'));
+    return trueFuture;
+  }
+}
+
+class MockSink with MethodCallsMixin implements Sink<int> {
+  @override
+  Future<void> close() {
+    calls.add(const MethodCall('close'));
+    return trueFuture;
+  }
+}
+
+class MockStreamSubscription
+    with MethodCallsMixin
+    implements StreamSubscription<int> {
+  Future<void> Function()? whenCancel;
+
+  @override
+  Future<void> cancel() {
+    calls.add(const MethodCall('cancel'));
+    return whenCancel?.call() ?? trueFuture;
+  }
+}