Chaining of setup/teardown.

pkg/unittest/lib/unittest.dart

 // Copyright (c) 2013, 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.
 
 /**
  * A library for writing dart unit tests.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 201 matching lines @@
 String _currentGroup = '';
 
 /** Separator used between group names and test names. */
 String groupSep = ' ';
 
 final List<TestCase> _testCases = new List<TestCase>();
 
 /** Tests executed in this suite. */
 final List<TestCase> testCases = new UnmodifiableListView<TestCase>(_testCases);
 
-/** Setup function called before each test in a group */
-Function _testSetup;
+/** Setup function called before each test in a group. */
+Function _testSetup = null;
 
-/** Teardown function called after each test in a group */
-Function _testTeardown;
+/** Teardown function called after each test in a group. */
+Function _testTeardown = null;
+
+/** Setup and teardown functions of parent group, for chaining. */
+Function _parentSetup = null;
+Function _parentTeardown = null;
 
 int _currentTestCaseIndex = 0;
 
 /** [TestCase] currently being executed. */
 TestCase get currentTestCase =>
     (_currentTestCaseIndex >= 0 && _currentTestCaseIndex < testCases.length)
         ? testCases[_currentTestCaseIndex]
         : null;
 
 /** Whether the framework is in an initialized state. */
@@ skipping 363 matching lines @@
   final parentGroup = _currentGroup;
   if (_currentGroup != '') {
     // Add a space.
     _currentGroup = '$_currentGroup$groupSep$description';
   } else {
     // The first group.
     _currentGroup = description;
   }
 
   // Groups can be nested, so we need to preserve the current
-  // settings for test setup/teardown.
-  Function parentSetup = _testSetup;
-  Function parentTeardown = _testTeardown;
+  // settings for test setup/teardown. We use a local copy here so we
+  // can nest multiple levels; we also have the global parent variables
+  // which are used for chaining.
+
+  Function _oldSetup = _testSetup;
+  Function _oldTeardown = _testTeardown;
+  Function _oldParentSetup = _parentSetup;
+  Function _oldParentTeardown = _parentTeardown;
+  _parentSetup = _testSetup;
+  _parentTeardown = _testTeardown;
 
   try {
-    _testSetup = null;
-    _testTeardown = null;
     body();
   } catch (e, trace) {
     var stack = (trace == null) ? '' : ': ${trace.toString()}';
     _uncaughtErrorMessage = "${e.toString()}$stack";
   } finally {
     // Now that the group is over, restore the previous one.
     _currentGroup = parentGroup;
-    _testSetup = parentSetup;
-    _testTeardown = parentTeardown;
+    _testSetup = _oldSetup;
+    _testTeardown = _oldTeardown;
+    _parentSetup = _oldParentSetup;
+    _parentTeardown = _oldParentTeardown;

[Siggi Cherem (dart-lang), 2013/04/19 23:55:05]

now that we have 5 of these, it might be worth creating a context object per
group:

class GroupContext {
  String name;
  Function setup;
  Function teardown;
  GroupContext parent;
}

then here you would simply do:
_currentGroup = _currentGroup.parent;

   }
 }
 
 /**
  * Register a [setUp] function for a test [group]. This function will
- * be called before each test in the group is run. Note that if groups
- * are nested only the most locally scoped [setUpTest] function will be run.
+ * be called before each test in the group is run.
  * [setUp] and [tearDown] should be called within the [group] before any
  * calls to [test]. The [setupTest] function can be asynchronous; in this
  * case it must return a [Future].
  */
 void setUp(Function setupTest) {
-  _testSetup = setupTest;
+  var parent = _parentSetup;
+  _testSetup = () {
+    var f = parent == null ? null : parent();
+    if (f is Future) {
+      return f.then((_) => setupTest());
+    } else {
+      return setupTest();
+    }
+  };
 }
 
 /**
  * Register a [tearDown] function for a test [group]. This function will
  * be called after each test in the group is run. Note that if groups
  * are nested only the most locally scoped [teardownTest] function will be run.
  * [setUp] and [tearDown] should be called within the [group] before any
  * calls to [test]. The [teardownTest] function can be asynchronous; in this
  * case it must return a [Future].
  */
 void tearDown(Function teardownTest) {
-  _testTeardown = teardownTest;
+  var parent = _parentTeardown;
+  _testTeardown = () {
+    var f = teardownTest();
+    if (parent == null) return f;
+    if (f is Future) {
+      // TODO(gram): as _parentTeardown is a global, do we need
+      // to first take a local copy so the value is fixed at the
+      // point that tearDown is called?
+      return f.then((_) => parent());
+    } else {
+      return parent();
+    }
+  };
 }
 
 /** Advance to the next test case. */
 void _nextTestCase() {
   _defer(() {
     _currentTestCaseIndex++;
     _nextBatch();
   });
 }
 
@@ skipping 209 matching lines @@
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef dynamic TestFunction();