Merge pull request #93 from Workiva/update_disposable_interface_version

RAP-2220 Update Module to the latest DisposableManager interface

lib/src/events_collection.dart

@@ -50,6 +50,6 @@ class EventsCollection extends Disposable {
   @mustCallSuper
   @protected
   void manageEvent(Event event) {
-    manageDisposer(() => event.close(_key));
+    getManagedDisposer(() => event.close(_key));
   }
 }

lib/src/lifecycle_module.dart

@@ -52,7 +52,7 @@ enum LifecycleState {
 /// Intended to be extended by most base module classes in order to provide a
 /// unified lifecycle API.
 abstract class LifecycleModule extends SimpleModule
-    implements DisposableManagerV3 {
+    implements DisposableManagerV5 {
   List<LifecycleModule> _childModules = [];
   StreamController<LifecycleModule> _didLoadChildModuleController;
   StreamController<LifecycleModule> _didLoadController;
@@ -227,6 +227,10 @@ abstract class LifecycleModule extends SimpleModule
   Future<T> getManagedDelayedFuture<T>(Duration duration, T callback()) =>
       _disposableProxy.getManagedDelayedFuture(duration, callback);
 
+  @override
+  ManagedDisposer getManagedDisposer(Disposer disposer) =>
+      _disposableProxy.getManagedDisposer(disposer);
+
   @override
   Timer getManagedPeriodicTimer(
           Duration duration, void callback(Timer timer)) =>
@@ -260,6 +264,13 @@ abstract class LifecycleModule extends SimpleModule
   /// Whether the module is currently unloading.
   bool get isUnloading => _state == LifecycleState.unloading;
 
+  @override
+  StreamSubscription<T> listenToStream<T>(
+          Stream<T> stream, void onData(T event),
+          {Function onError, void onDone(), bool cancelOnError}) =>
+      _disposableProxy.listenToStream(stream, onData,
+          onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+
   //--------------------------------------------------------
   // Public methods that can be used directly to trigger
   // module lifecycle / check current lifecycle state
@@ -383,8 +394,14 @@ abstract class LifecycleModule extends SimpleModule
       _disposableProxy.manageDisposable(disposable);
 
   /// Ensures a given [Disposer] callback is called when the module is unloaded.
+  ///
+  /// Deprecated: 1.3.0
+  /// To be removed: 2.0.0
+  ///
+  /// Use `getManagedDisposer` instead.
   @override
   void manageDisposer(Disposer disposer) =>
+      // ignore: deprecated_member_use
       _disposableProxy.manageDisposer(disposer);
 
   /// Ensures a given [StreamController] is closed when the module is unloaded.
@@ -394,8 +411,15 @@ abstract class LifecycleModule extends SimpleModule
 
   /// Ensures a given [StreamSubscription] is cancelled when the module is
   /// unloaded.
+  ///
+  /// Deprecated: 1.3.0
+  /// To be removed: 2.0.0
+  ///
+  /// Use `listenToStream` instead.
+  @deprecated
   @override
   void manageStreamSubscription(StreamSubscription subscription) =>
+      // ignore: deprecated_member_use
       _disposableProxy.manageStreamSubscription(subscription);
 
   /// Public method to suspend the module.
@@ -683,9 +707,9 @@ abstract class LifecycleModule extends SimpleModule
   /// A utility to logging LifecycleModule lifecycle events
   void _logLifecycleEvents(
       String logLabel, Stream<dynamic> lifecycleEventStream) {
-    _postUnloadDisposable.manageStreamSubscription(lifecycleEventStream.listen(
-        (_) => _logger.fine(logLabel),
-        onError: (error) => _logger.warning('$logLabel error: $error')));
+    _postUnloadDisposable.listenToStream(
+        lifecycleEventStream, (_) => _logger.fine(logLabel),
+        onError: (error) => _logger.warning('$logLabel error: $error'));
   }
 
   /// Handles a child [LifecycleModule]'s [didUnload] event.

pubspec.yaml

@@ -14,7 +14,7 @@ dependencies:
   logging: ^0.11.0
   meta: ^1.0.0
   platform_detect: ^1.1.0
-  w_common: ^1.4.0
+  w_common: ^1.7.2
 
 dev_dependencies:
   browser: ^0.10.0+2

test/lifecycle_module_test.dart

@@ -32,8 +32,10 @@ class MockStreamSubscription extends Mock implements StreamSubscription<Null> {}
 class TestLifecycleModule extends LifecycleModule {
   Iterable<StreamSubscription<LifecycleModule>> _eventListStreamSubscriptions;
   bool _managedDisposerWasCalled = false;
+  bool _getManagedDisposerWasCalled = false;
 
   final Disposable managedDisposable;
+  ManagedDisposer managedDisposer;
   final StreamController<Null> managedStreamController;
   final MockStreamSubscription managedStreamSubscription;
   Error onDidLoadChildModuleError;
@@ -62,11 +64,15 @@ class TestLifecycleModule extends LifecycleModule {
     mockShouldUnload = true;
 
     // Manage disposables
+    managedDisposer = getManagedDisposer(() {
+      _getManagedDisposerWasCalled = true;
+    });
     manageDisposable(managedDisposable);
     manageDisposer(() {
       _managedDisposerWasCalled = true;
     });
     manageStreamController(managedStreamController);
+    // ignore: deprecated_member_use
     manageStreamSubscription(managedStreamSubscription);
 
     var getEventListAdder =
@@ -100,6 +106,8 @@ class TestLifecycleModule extends LifecycleModule {
     ];
   }
 
+  bool get getManagedDisposerWasCalled => _getManagedDisposerWasCalled;
+
   bool get managedDisposerWasCalled => _managedDisposerWasCalled;
 
   // Overriding without re-applying the @protected annotation allows us to call
@@ -638,14 +646,23 @@ void main() {
         await module.load();
         expect(module.managedDisposable.isDisposed, isFalse);
         expect(module.managedDisposerWasCalled, isFalse);
+        expect(module.getManagedDisposerWasCalled, isFalse);
         expect(module.managedStreamController.isClosed, isFalse);
         verifyNever(module.managedStreamSubscription.cancel());
 
+        var controller = new StreamController();
+        controller.onCancel = expectAsync1(([_]) {}, count: 1);
+        module.listenToStream(
+            controller.stream, expectAsync1((_) {}, count: 0));
+
         await module.unload();
         expect(module.managedDisposable.isDisposed, isTrue);
         expect(module.managedDisposerWasCalled, isTrue);
+        expect(module.getManagedDisposerWasCalled, isTrue);
         expect(module.managedStreamController.isClosed, isTrue);
         verify(module.managedStreamSubscription.cancel());
+        controller.add(null);
+        await controller.close();
       });
 
       testInvalidTransitions(