Add a heartbeat for the test timeout.

lib/src/backend/invoker.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.backend.invoker;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 75 matching lines @@
   }
 
   /// The current invoker, or `null` if none is defined.
   ///
   /// An invoker is only set within the zone scope of a running test.
   static Invoker get current {
     // TODO(nweiz): Use a private symbol when dart2js supports it (issue 17526).
     return Zone.current[#test.invoker];
   }
 
+  /// The timer for tracking timeouts.
+  ///
+  /// This will be `null` until the test starts running.
+  Timer _timeoutTimer;
+
   Invoker._(Suite suite, LocalTest test)
       : metadata = suite.metadata.merge(test.metadata) {
     _controller = new LiveTestController(suite, test, _onRun, () {
       _closed = true;
     });
   }
 
   /// Tells the invoker that there's a callback running that it should wait for
   /// before considering the test successful.
   ///
   /// Each call to [addOutstandingCallback] should be followed by a call to
   /// [removeOutstandingCallback] once the callbak is no longer running. Note
   /// that only successful tests wait for outstanding callbacks; as soon as a
   /// test experiences an error, any further calls to [addOutstandingCallback]
   /// or [removeOutstandingCallback] will do nothing.
   ///
   /// Throws a [ClosedException] if this test has been closed.
   void addOutstandingCallback() {
     if (closed) throw new ClosedException();
     _outstandingCallbacks.addOutstandingCallback();
   }
 
   /// Tells the invoker that a callback declared with [addOutstandingCallback]
   /// is no longer running.
-  void removeOutstandingCallback() =>
-      _outstandingCallbacks.removeOutstandingCallback();
+  void removeOutstandingCallback() {
+    heartbeat();
+    _outstandingCallbacks.removeOutstandingCallback();
+  }
 
   /// Runs [fn] and returns once all (registered) outstanding callbacks it
   /// transitively invokes have completed.
   ///
   /// If [fn] itself returns a future, this will automatically wait until that
   /// future completes as well.
   ///
   /// Note that outstanding callbacks registered within [fn] will *not* be
   /// registered as outstanding callback outside of [fn].
   Future waitForOutstandingCallbacks(fn()) {
+    heartbeat();
+
     var counter = new OutstandingCallbackCounter();
     runZoned(() {
       // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
       // two stable versions.
       new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
     }, zoneValues: {
       // Use the invoker as a key so that multiple invokers can have different
       // outstanding callback counters at once.
       this: counter
     });
 
     return counter.noOutstandingCallbacks;
   }
 
+  /// Notifies the invoker that progress is being made.
+  ///
+  /// Each heartbeat resets the timeout timer. This helps ensure that
+  /// long-running tests that still make progress don't time out.
+  void heartbeat() {
+    if (_liveTest.isComplete) return;
+    if (_timeoutTimer != null) _timeoutTimer.cancel();
+
+    var timeout = metadata.timeout.apply(new Duration(seconds: 30));

[kevmoo, 2015/05/29 01:26:46]

This implies that 30s is the max time allowed between async actions before a
timeout happens?

At least a to-do to make this plug-able?

[nweiz, 2015/05/29 20:25:39]

This is already pluggable via the @Timeout annotation.

+    _timeoutTimer = new Timer(timeout, () {
+      if (liveTest.isComplete) return;
+      handleError(
+          new TimeoutException(
+              "Test timed out after ${niceDuration(timeout)}.", timeout));
+    });
+  }
+
   /// Notifies the invoker of an asynchronous error.
   ///
   /// Note that calling this explicitly is rarely necessary, since any
   /// otherwise-uncaught errors will be forwarded to the invoker anyway.
   void handleError(error, [StackTrace stackTrace]) {
     if (stackTrace == null) stackTrace = new Chain.current();
 
     var afterSuccess = liveTest.isComplete &&
         liveTest.state.result == Result.success;
 
@@ skipping 19 matching lines @@
   /// The method that's run when the test is started.
   void _onRun() {
     _controller.setState(const State(Status.running, Result.success));
 
     var outstandingCallbacksForBody = new OutstandingCallbackCounter();
 
     // TODO(nweiz): Use async/await here once issue 23497 has been fixed in two
     // stable versions.
     Chain.capture(() {
       runZonedWithValues(() {
-        // TODO(nweiz): Reset this timer whenever the user's code interacts
-        // with the library.
-        var timeout = metadata.timeout.apply(new Duration(seconds: 30));
-        var timer = new Timer(timeout, () {
-          if (liveTest.isComplete) return;
-          handleError(
-              new TimeoutException(
-                  "Test timed out after ${niceDuration(timeout)}.", timeout));
-        });
-
         // Run the test asynchronously so that the "running" state change has
         // a chance to hit its event handler(s) before the test produces an
         // error. If an error is emitted before the first state change is
         // handled, we can end up with [onError] callbacks firing before the
         // corresponding [onStateChange], which violates the timing
         // guarantees.
         new Future(_test._body)
             .then((_) => removeOutstandingCallback());
 
         _outstandingCallbacks.noOutstandingCallbacks.then((_) {
           if (_test._tearDown == null) return null;
 
           // Reset the outstanding callback counter to wait for callbacks from
           // the test's `tearDown` to complete.
           return waitForOutstandingCallbacks(() =>
               runZoned(_test._tearDown, onError: handleError));
         }).then((_) {
-          timer.cancel();
+          _timeoutTimer.cancel();
           _controller.setState(
               new State(Status.complete, liveTest.state.result));
 
           // Use [Timer.run] here to avoid starving the DOM or other
           // non-microtask events.
           Timer.run(_controller.completer.complete);
         });
       }, zoneValues: {
         #test.invoker: this,
         // Use the invoker as a key so that multiple invokers can have different
         // outstanding callback counters at once.
         this: outstandingCallbacksForBody
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: handleError);
     });
   }
 }