Big merge from experimental to bleeding edge.

utils/tests/pub/test_pub.dart

 // Copyright (c) 2012, 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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
+import 'dart:async';
 import 'dart:io';
-import 'dart:isolate';
-import 'dart:json';
+import 'dart:json' as json;
 import 'dart:math';
 import 'dart:uri';
 
 import '../../../pkg/oauth2/lib/oauth2.dart' as oauth2;
 import '../../../pkg/path/lib/path.dart' as path;
 import '../../../pkg/unittest/lib/unittest.dart';
 import '../../../pkg/http/lib/testing.dart';
 import '../../lib/file_system.dart' as fs;
 import '../../pub/entrypoint.dart';
 import '../../pub/git_source.dart';
@@ skipping 49 matching lines @@
 Future<int> get port => _portCompleter.future;
 
 /// Creates an HTTP server to serve [contents] as static files. This server will
 /// exist only for the duration of the pub run.
 ///
 /// Subsequent calls to [serve] will replace the previous server.
 void serve([List<Descriptor> contents]) {
   var baseDir = dir("serve-dir", contents);
 
   _schedule((_) {
-    return _closeServer().transform((_) {
+    return _closeServer().then((_) {
       _server = new HttpServer();
       _server.defaultRequestHandler = (request, response) {
         var path = request.uri.replaceFirst("/", "").split("/");
         response.persistentConnection = false;
         var stream;
         try {
           stream = baseDir.load(path);
         } catch (e) {
           response.statusCode = 404;
           response.contentLength = 0;
           response.outputStream.close();
           return;
         }
 
         var future = consumeInputStream(stream);
         future.then((data) {
           response.statusCode = 200;
           response.contentLength = data.length;
           response.outputStream.write(data);
           response.outputStream.close();
-        });
-
-        future.handleException((e) {
+        }).catchError((e) {
           print("Exception while handling ${request.uri}: $e");
           response.statusCode = 500;
           response.reasonPhrase = e.message;
           response.outputStream.close();
         });
       };
       _server.listen("127.0.0.1", 0);
       _portCompleter.complete(_server.port);
       _scheduleCleanup((_) => _closeServer());
       return null;
@@ skipping 37 matching lines @@
     _servedPackageDir = dir('packages', []);
     serve([_servedPackageDir]);
 
     _scheduleCleanup((_) {
       _servedPackages = null;
       _servedPackageDir = null;
     });
   }
 
   _schedule((_) {
-    return _awaitObject(pubspecs).transform((resolvedPubspecs) {
+    return _awaitObject(pubspecs).then((resolvedPubspecs) {
       for (var spec in resolvedPubspecs) {
         var name = spec['name'];
         var version = spec['version'];
         var versions = _servedPackages.putIfAbsent(
             name, () => <String, String>{});
         versions[version] = yaml(spec);
       }
 
       _servedPackageDir.contents.clear();
       for (var name in _servedPackages.keys) {
-        var versions = _servedPackages[name].keys;
+        var versions = _servedPackages[name].keys.toList());
         _servedPackageDir.contents.addAll([
           file('$name.json',
-              JSON.stringify({'versions': versions})),
+              json.stringify({'versions': versions})),
           dir(name, [
-            dir('versions', flatten(versions.map((version) {
+            dir('versions', flatten(versions.mappedBy((version) {
               return [
                 file('$version.yaml', _servedPackages[name][version]),
                 tar('$version.tar.gz', [
                   file('pubspec.yaml', _servedPackages[name][version]),
                   libDir(name, '$name $version')
                 ])
               ];
             })))
           ])
         ]);
       }
     });
   });
 }
 
 /// Converts [value] into a YAML string.
-String yaml(value) => JSON.stringify(value);
+String yaml(value) => json.stringify(value);
 
 /// Describes a package that passes all validation.
 Descriptor get normalPackage => dir(appPath, [
   libPubspec("test_pkg", "1.0.0"),
   file("LICENSE", "Eh, do what you want."),
   dir("lib", [
     file("test_pkg.dart", "int i = 1;")
   ])
 ]);
 
 /// Describes a file named `pubspec.yaml` with the given YAML-serialized
 /// [contents], which should be a serializable object.
 ///
 /// [contents] may contain [Future]s that resolve to serializable objects,
 /// which may in turn contain [Future]s recursively.
 Descriptor pubspec(Map contents) {
-  return async(_awaitObject(contents).transform((resolvedContents) =>
+  return async(_awaitObject(contents).then((resolvedContents) =>
       file("pubspec.yaml", yaml(resolvedContents))));
 }
 
 /// Describes a file named `pubspec.yaml` for an application package with the
 /// given [dependencies].
 Descriptor appPubspec(List dependencies) {
   return pubspec({
     "name": "myapp",
     "dependencies": _dependencyListToMap(dependencies)
   });
@@ skipping 29 matching lines @@
   };
   if (dependencies != null) {
     package["dependencies"] = _dependencyListToMap(dependencies);
   }
   return package;
 }
 
 /// Describes a map representing a dependency on a package in the package
 /// repository.
 Map dependency(String name, [String versionConstraint]) {
-  var url = port.transform((p) => "http://localhost:$p");
+  var url = port.then((p) => "http://localhost:$p");
   var dependency = {"hosted": {"name": name, "url": url}};
   if (versionConstraint != null) dependency["version"] = versionConstraint;
   return dependency;
 }
 
 /// Describes a directory for a package installed from the mock package server.
 /// This directory is of the form found in the global package cache.
 DirectoryDescriptor packageCacheDir(String name, String version) {
   return dir("$name-$version", [
     libDir(name, '$name $version')
@@ skipping 49 matching lines @@
 DirectoryDescriptor cacheDir(Map packages) {
   var contents = <Descriptor>[];
   packages.forEach((name, versions) {
     if (versions is! List) versions = [versions];
     for (var version in versions) {
       contents.add(packageCacheDir(name, version));
     }
   });
   return dir(cachePath, [
     dir('hosted', [
-      async(port.transform((p) => dir('localhost%58$p', contents)))
+      async(port.then((p) => dir('localhost%58$p', contents)))
     ])
   ]);
 }
 
 /// Describes the file in the system cache that contains the client's OAuth2
 /// credentials. The URL "/token" on [server] will be used as the token
 /// endpoint for refreshing the access token.
 Descriptor credentialsFile(
     ScheduledServer server,
     String accessToken,
     {String refreshToken,
      Date expiration}) {
-  return async(server.url.transform((url) {
+  return async(server.url.then((url) {
     return dir(cachePath, [
       file('credentials.json', new oauth2.Credentials(
           accessToken,
           refreshToken,
           url.resolve('/token'),
           ['https://www.googleapis.com/auth/userinfo.email'],
           expiration).toJson())
     ]);
   }));
 }
 
 /// Describes the application directory, containing only a pubspec specifying
 /// the given [dependencies].
 DirectoryDescriptor appDir(List dependencies) =>
   dir(appPath, [appPubspec(dependencies)]);
 
 /// Converts a list of dependencies as passed to [package] into a hash as used
 /// in a pubspec.
 Future<Map> _dependencyListToMap(List<Map> dependencies) {
-  return _awaitObject(dependencies).transform((resolvedDependencies) {
+  return _awaitObject(dependencies).then((resolvedDependencies) {
     var result = <String, Map>{};
     for (var dependency in resolvedDependencies) {
-      var keys = dependency.keys.filter((key) => key != "version");
+      var keys = dependency.keys.where((key) => key != "version");
       var sourceName = only(keys);
       var source;
       switch (sourceName) {
       case "git":
         source = new GitSource();
         break;
       case "hosted":
         source = new HostedSource();
         break;
       case "sdk":
@@ skipping 65 matching lines @@
 final _TIMEOUT = 30000;
 
 /// Runs all the scheduled events for a test case. This should only be called
 /// once per test case.
 void run() {
   var createdSandboxDir;
 
   var asyncDone = expectAsync0(() {});
 
   Future cleanup() {
-    return _runScheduled(createdSandboxDir, _scheduledCleanup).chain((_) {
+    return _runScheduled(createdSandboxDir, _scheduledCleanup).then((_) {
       _scheduled = null;
       _scheduledCleanup = null;
       _scheduledOnException = null;
       if (createdSandboxDir != null) return deleteDir(createdSandboxDir);
       return new Future.immediate(null);
     });
   }
 
-  final future = _setUpSandbox().chain((sandboxDir) {
+  final future = _setUpSandbox().then((sandboxDir) {
     createdSandboxDir = sandboxDir;
     return _runScheduled(sandboxDir, _scheduled);
   });
 
-  future.handleException((error) {
+  future.catchError((error) {
     // If an error occurs during testing, delete the sandbox, throw the error so
     // that the test framework sees it, then finally call asyncDone so that the
     // test framework knows we're done doing asynchronous stuff.
     var subFuture = _runScheduled(createdSandboxDir, _scheduledOnException)
-        .chain((_) => cleanup());
-    subFuture.handleException((e) {
-      print("Exception while cleaning up: $e");
-      print(subFuture.stackTrace);
-      registerException(error, subFuture.stackTrace);
+        .then((_) => cleanup());
+    subFuture.catchError((e) {
+      print("Exception while cleaning up: ${e.error}");
+      print(e.stackTrace);
+      registerException(e.error, e.stackTrace);
       return true;
     });
-    subFuture.then((_) => registerException(error, future.stackTrace));
-    return true;
-  });
-
   timeout(future, _TIMEOUT, 'waiting for a test to complete')
-      .chain((_) => cleanup())
+      .then((_) => cleanup())
       .then((_) => asyncDone());
 }
 
 /// Get the path to the root "util/test/pub" directory containing the pub
 /// tests.
 String get testDirectory {
   var dir = new Options().script;
   while (basename(dir) != 'pub') dir = dirname(dir);
 
   return getFullPath(dir);
 }
 
 /// Schedules a call to the Pub command-line utility. Runs Pub with [args] and
 /// validates that its results match [output], [error], and [exitCode].
 void schedulePub({List args, Pattern output, Pattern error,
     Future<Uri> tokenEndpoint, int exitCode: 0}) {
   _schedule((sandboxDir) {
     return _doPub(runProcess, sandboxDir, args, tokenEndpoint)
-        .transform((result) {
+        .then((result) {
       var failures = [];
 
       _validateOutput(failures, 'stdout', output, result.stdout);
       _validateOutput(failures, 'stderr', error, result.stderr);
 
       if (result.exitCode != exitCode) {
         failures.add(
             'Pub returned exit code ${result.exitCode}, expected $exitCode.');
       }
 
       if (failures.length > 0) {
         if (error == null) {
           // If we aren't validating the error, still show it on failure.
           failures.add('Pub stderr:');
-          failures.addAll(result.stderr.map((line) => '| $line'));
+          failures.addAll(result.stderr.mappedBy((line) => '| $line'));
         }
 
         throw new ExpectException(Strings.join(failures, '\n'));
       }
 
       return null;
     });
   });
 }
 
@@ skipping 90 matching lines @@
 }
 
 /// Skips the current test if Git is not installed. This validates that the
 /// current test is running on a buildbot in which case we expect git to be
 /// installed. If we are not running on the buildbot, we will instead see if
 /// git is installed and skip the test if not. This way, users don't need to
 /// have git installed to run the tests locally (unless they actually care
 /// about the pub git tests).
 void ensureGit() {
   _schedule((_) {
-    return isGitInstalled.transform((installed) {
+    return isGitInstalled.then((installed) {
       if (!installed &&
           !Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
         _abortScheduled = true;
       }
       return null;
     });
   });
 }
 
 /// Use [client] as the mock HTTP client for this test.
 ///
 /// Note that this will only affect HTTP requests made via http.dart in the
 /// parent process.
 void useMockClient(MockClient client) {
   var oldInnerClient = httpClient.inner;
   httpClient.inner = client;
   _scheduleCleanup((_) {
     httpClient.inner = oldInnerClient;
   });
 }
 
 Future<Directory> _setUpSandbox() => createTempDir();
 
 Future _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
-  var iterator = scheduled.iterator();
+  var iterator = scheduled.iterator;
 
   Future runNextEvent(_) {
-    if (_abortScheduled || !iterator.hasNext) {
+    if (_abortScheduled || !iterator.moveNext()) {
       _abortScheduled = false;
       scheduled.clear();
       return new Future.immediate(null);
     }
 
-    var future = iterator.next()(parentDir);
+    var future = iterator.current(parentDir);
     if (future != null) {
-      return future.chain(runNextEvent);
+      return future.then(runNextEvent);
     } else {
       return runNextEvent(null);
     }
   }
 
   return runNextEvent(null);
 }
 
 /// Compares the [actual] output from running pub with [expected]. For [String]
 /// patterns, ignores leading and trailing whitespace differences and tries to
@@ skipping 12 matching lines @@
 
 void _validateOutputRegex(List<String> failures, String pipe,
                           RegExp expected, List<String> actual) {
   var actualText = Strings.join(actual, '\n');
   if (actualText.contains(expected)) return;
 
   if (actual.length == 0) {
     failures.add('Expected $pipe to match "${expected.pattern}" but got none.');
   } else {
     failures.add('Expected $pipe to match "${expected.pattern}" but got:');
-    failures.addAll(actual.map((line) => '| $line'));
+    failures.addAll(actual.mappedBy((line) => '| $line'));
   }
 }
 
 void _validateOutputString(List<String> failures, String pipe,
                            String expectedText, List<String> actual) {
   final expected = expectedText.split('\n');
 
   // Strip off the last line. This lets us have expected multiline strings
   // where the closing ''' is on its own line. It also fixes '' expected output
   // to expect zero lines of output, not a single empty line.
@@ skipping 24 matching lines @@
       } else {
         // Output is OK, but include it in case other lines are wrong.
         results.add('| ${actual[i]}');
       }
     }
   }
 
   // If any lines mismatched, show the expected and actual.
   if (failed) {
     failures.add('Expected $pipe:');
-    failures.addAll(expected.map((line) => '| $line'));
+    failures.addAll(expected.mappedBy((line) => '| $line'));
     failures.add('Got:');
     failures.addAll(results);
   }
 }
 
 /// Base class for [FileDescriptor] and [DirectoryDescriptor] so that a
 /// directory can contain a heterogeneous collection of files and
 /// subdirectories.
 abstract class Descriptor {
   /// The name of this file or directory. This must be a [String] if the file
@@ skipping 37 matching lines @@
     throw 'Pattern $name must be a string.';
   }
 
   /// Validates that at least one file in [dir] matching [name] is valid
   /// according to [validate]. [validate] should complete to an exception if
   /// the input path is invalid.
   Future _validateOneMatch(String dir, Future validate(String path)) {
     // Special-case strings to support multi-level names like "myapp/packages".
     if (name is String) {
       var path = join(dir, name);
-      return exists(path).chain((exists) {
+      return exists(path).then((exists) {
         if (!exists) Expect.fail('File $name in $dir not found.');
         return validate(path);
       });
     }
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
-    return listDir(dir).chain((files) {
-      var matches = files.filter((file) => endsWithPattern(file, name));
-      if (matches.length == 0) {
+    return listDir(dir).then((files) {
+      var matches = files.where((file) => endsWithPattern(file, name)).toList();
+      if (matches.isEmpty) {
         Expect.fail('No files in $dir match pattern $name.');
       }
       if (matches.length == 1) return validate(matches[0]);
 
       var failures = [];
       var successes = 0;
       var completer = new Completer();
       checkComplete() {
         if (failures.length + successes != matches.length) return;
         if (successes > 0) {
           completer.complete(null);
           return;
         }
 
         var error = new StringBuffer();
         error.add("No files named $name in $dir were valid:\n");
         for (var failure in failures) {
           error.add("  ").add(failure).add("\n");
         }
         completer.completeException(
             new ExpectException(error.toString()), stackTrace);
       }
 
       for (var match in matches) {
         var future = validate(match);
 
-        future.handleException((e) {
+        future.catchError((e) {
           failures.add(e);
           checkComplete();
-          return true;
         });
 
         future.then((_) {
           successes++;
           checkComplete();
-        });
+        }).catchError(() {});
       }
       return completer.future;
     });
   }
 }
 
 /// Describes a file. These are used both for setting up an expected directory
 /// tree before running a test, and for validating that the file system matches
 /// some expectations after running it.
 class FileDescriptor extends Descriptor {
@@ skipping 10 matching lines @@
 
   /// Deletes the file within [dir]. Returns a [Future] that is completed after
   /// the deletion is done.
   Future delete(dir) {
     return deleteFile(join(dir, _stringName));
   }
 
   /// Validates that this file correctly matches the actual file at [path].
   Future validate(String path) {
     return _validateOneMatch(path, (file) {
-      return readTextFile(file).transform((text) {
+      return readTextFile(file).then((text) {
         if (text == contents) return null;
 
         Expect.fail('File $file should contain:\n\n$contents\n\n'
                     'but contained:\n\n$text');
       });
     });
   }
 
   /// Loads the contents of the file.
   InputStream load(List<String> path) {
@@ skipping 17 matching lines @@
   final List<Descriptor> contents;
 
   DirectoryDescriptor(Pattern name, List<Descriptor> contents)
     : this.contents = contents == null ? <Descriptor>[] : contents,
       super(name);
 
   /// Creates the file within [dir]. Returns a [Future] that is completed after
   /// the creation is done.
   Future<Directory> create(parentDir) {
     // Create the directory.
-    return ensureDir(join(parentDir, _stringName)).chain((dir) {
+    return ensureDir(join(parentDir, _stringName)).then((dir) {
       if (contents == null) return new Future<Directory>.immediate(dir);
 
       // Recursively create all of its children.
-      final childFutures = contents.map((child) => child.create(dir));
+      final childFutures =
+          contents.mappedBy((child) => child.create(dir)).toList();
       // Only complete once all of the children have been created too.
-      return Futures.wait(childFutures).transform((_) => dir);
+      return Futures.wait(childFutures).then((_) => dir);
     });
   }
 
   /// Deletes the directory within [dir]. Returns a [Future] that is completed
   /// after the deletion is done.
   Future delete(dir) {
     return deleteDir(join(dir, _stringName));
   }
 
   /// Validates that the directory at [path] contains all of the expected
   /// contents in this descriptor. Note that this does *not* check that the
   /// directory doesn't contain other unexpected stuff, just that it *does*
   /// contain the stuff we do expect.
   Future validate(String path) {
     return _validateOneMatch(path, (dir) {
       // Validate each of the items in this directory.
-      final entryFutures = contents.map((entry) => entry.validate(dir));
+      final entryFutures =
+          contents.mappedBy((entry) => entry.validate(dir)).toList();
 
       // If they are all valid, the directory is valid.
-      return Futures.wait(entryFutures).transform((entries) => null);
+      return Futures.wait(entryFutures).then((entries) => null);
     });
   }
 
   /// Loads [path] from within this directory.
   InputStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: is a directory.";
     }
 
     for (var descriptor in contents) {
       if (descriptor.name == path[0]) {
         return descriptor.load(path.getRange(1, path.length - 1));
       }
     }
 
     throw "Directory $name doesn't contain ${Strings.join(path, '/')}.";
   }
 }
 
 /// Wraps a [Future] that will complete to a [Descriptor] and makes it behave
 /// like a concrete [Descriptor]. This is necessary when the contents of the
 /// descriptor depends on information that's not available until part of the
 /// test run is completed.
 class FutureDescriptor extends Descriptor {
   Future<Descriptor> _future;
 
   FutureDescriptor(this._future) : super('<unknown>');
 
-  Future create(dir) => _future.chain((desc) => desc.create(dir));
+  Future create(dir) => _future.then((desc) => desc.create(dir));
 
-  Future validate(dir) => _future.chain((desc) => desc.validate(dir));
+  Future validate(dir) => _future.then((desc) => desc.validate(dir));
 
-  Future delete(dir) => _future.chain((desc) => desc.delete(dir));
+  Future delete(dir) => _future.then((desc) => desc.delete(dir));
 
   InputStream load(List<String> path) {
     var resultStream = new ListInputStream();
     _future.then((desc) => pipeInputToInput(desc.load(path), resultStream));
     return resultStream;
   }
 }
 
 /// Describes a Git repository and its contents.
 class GitRepoDescriptor extends DirectoryDescriptor {
@@ skipping 17 matching lines @@
     ]);
   }
 
   /// Schedules changes to be committed to the Git repository.
   void scheduleCommit() => _schedule((dir) => this.commit(dir));
 
   /// Return a Future that completes to the commit in the git repository
   /// referred to by [ref] at the current point in the scheduled test run.
   Future<String> revParse(String ref) {
     return _scheduleValue((parentDir) {
-      return super.create(parentDir).chain((rootDir) {
+      return super.create(parentDir).then((rootDir) {
         return _runGit(['rev-parse', ref], rootDir);
-      }).transform((output) => output[0]);
+      }).then((output) => output[0]);
     });
   }
 
   /// Schedule a Git command to run in this repository.
   void scheduleGit(List<String> args) {
     _schedule((parentDir) {
       var gitDir = new Directory(join(parentDir, name));
       return _runGit(args, gitDir);
     });
   }
 
   Future _runGitCommands(parentDir, List<List<String>> commands) {
     var workingDir;
 
     Future runGitStep(_) {
       if (commands.isEmpty) return new Future.immediate(workingDir);
       var command = commands.removeAt(0);
-      return _runGit(command, workingDir).chain(runGitStep);
+      return _runGit(command, workingDir).then(runGitStep);
     }
 
-    return super.create(parentDir).chain((rootDir) {
+    return super.create(parentDir).then((rootDir) {
       workingDir = rootDir;
       return runGitStep(null);
     });
   }
 
   Future<String> _runGit(List<String> args, Directory workingDir) {
     // Explicitly specify the committer information. Git needs this to commit
     // and we don't want to rely on the buildbots having this already set up.
     var environment = {
       'GIT_AUTHOR_NAME': 'Pub Test',
       'GIT_AUTHOR_EMAIL': 'pub@dartlang.org',
       'GIT_COMMITTER_NAME': 'Pub Test',
       'GIT_COMMITTER_EMAIL': 'pub@dartlang.org'
     };
 
     return runGit(args, workingDir: workingDir.path,
-        environment: environment).transform((result) {
+        environment: environment).then((result) {
       if (!result.success) {
         throw "Error running: git ${Strings.join(args, ' ')}\n"
             "${Strings.join(result.stderr, '\n')}";
       }
 
       return result.stdout;
     });
   }
 }
 
 /// Describes a gzipped tar file and its contents.
 class TarFileDescriptor extends Descriptor {
   final List<Descriptor> contents;
 
   TarFileDescriptor(Pattern name, this.contents)
   : super(name);
 
   /// Creates the files and directories within this tar file, then archives
   /// them, compresses them, and saves the result to [parentDir].
   Future<File> create(parentDir) {
     // TODO(rnystrom): Use withTempDir().
     var tempDir;
-    return createTempDir().chain((_tempDir) {
+    return createTempDir().then((_tempDir) {
       tempDir = _tempDir;
-      return Futures.wait(contents.map((child) => child.create(tempDir)));
-    }).chain((createdContents) {
+      return Futures.wait(contents.mappedBy((child) => child.create(tempDir)));
+    }).then((createdContents) {
       return consumeInputStream(createTarGz(createdContents, baseDir: tempDir));
-    }).chain((bytes) {
+    }).then((bytes) {
       return new File(join(parentDir, _stringName)).writeAsBytes(bytes);
-    }).chain((file) {
-      return deleteDir(tempDir).transform((_) => file);
+    }).then((file) {
+      return deleteDir(tempDir).then((_) => file);
     });
   }
 
   /// Validates that the `.tar.gz` file at [path] contains the expected
   /// contents.
   Future validate(String path) {
     throw "TODO(nweiz): implement this";
   }
 
   Future delete(dir) {
     throw new UnsupportedError('');
   }
 
   /// Loads the contents of this tar file.
   InputStream load(List<String> path) {
     if (!path.isEmpty) {
       var joinedPath = Strings.join(path, '/');
       throw "Can't load $joinedPath from within $name: not a directory.";
     }
 
     var sinkStream = new ListInputStream();
     var tempDir;
     // TODO(rnystrom): Use withTempDir() here.
     // TODO(nweiz): propagate any errors to the return value. See issue 3657.
-    createTempDir().chain((_tempDir) {
+    createTempDir().then((_tempDir) {
       tempDir = _tempDir;
       return create(tempDir);
     }).then((tar) {
       var sourceStream = tar.openInputStream();
       pipeInputToInput(sourceStream, sinkStream).then((_) {
         tempDir.delete(recursive: true);
       });
     });
     return sinkStream;
   }
 }
 
 /// A descriptor that validates that no file exists with the given name.
 class NothingDescriptor extends Descriptor {
   NothingDescriptor(String name) : super(name);
 
   Future create(dir) => new Future.immediate(null);
   Future delete(dir) => new Future.immediate(null);
 
   Future validate(String dir) {
-    return exists(join(dir, name)).transform((exists) {
+    return exists(join(dir, name)).then((exists) {
       if (exists) Expect.fail('File $name in $dir should not exist.');
     });
   }
 
   InputStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: it doesn't exist.";
     } else {
       throw "Can't load ${Strings.join(path, '/')} from within $name: $name "
         "doesn't exist.";
     }
   }
 }
 
 /// A function that creates a [Validator] subclass.
 typedef Validator ValidatorCreator(Entrypoint entrypoint);
 
 /// Schedules a single [Validator] to run on the [appPath]. Returns a scheduled
 /// Future that contains the erros and warnings produced by that validator.
 Future<Pair<List<String>, List<String>>> schedulePackageValidation(
     ValidatorCreator fn) {
   return _scheduleValue((sandboxDir) {
     var cache = new SystemCache.withSources(
         join(sandboxDir, cachePath),
         join(sandboxDir, sdkPath));
 
     return Entrypoint.load(join(sandboxDir, appPath), cache)
         .chain((entrypoint) {
       var validator = fn(entrypoint);
-      return validator.validate().transform((_) {
+      return validator.validate().then((_) {
         return new Pair(validator.errors, validator.warnings);
       });
     });
   });
 }
 
 /// A matcher that matches a Pair.
 Matcher pairOf(Matcher firstMatcher, Matcher lastMatcher) =>
    new _PairMatcher(firstMatcher, lastMatcher);
 
@@ skipping 52 matching lines @@
   /// Whether the user has scheduled the end of this process by calling either
   /// [shouldExit] or [kill].
   bool _endScheduled = false;
 
   /// Whether the process is expected to terminate at this point.
   bool _endExpected = false;
 
   /// Wraps a [Process] [Future] in a scheduled process.
   ScheduledProcess(this.name, Future<Process> process)
     : _process = process,
-      _stdout = process.transform((p) => new StringInputStream(p.stdout)),
-      _stderr = process.transform((p) => new StringInputStream(p.stderr)) {
+      _stdout = process.then((p) => new StringInputStream(p.stdout)),
+      _stderr = process.then((p) => new StringInputStream(p.stderr)) {
 
     _schedule((_) {
       if (!_endScheduled) {
         throw new StateError("Scheduled process $name must have shouldExit() "
             "or kill() called before the test is run.");
       }
 
-      return _process.transform((p) {
+      return _process.then((p) {
         p.onExit = (c) {
           if (_endExpected) {
             _exitCodeCompleter.complete(c);
             return;
           }
 
           // Sleep for half a second in case _endExpected is set in the next
           // scheduled event.
           sleep(500).then((_) {
             if (_endExpected) {
@@ skipping 73 matching lines @@
     }
 
     return _scheduleValue((_) {
       return timeout(_stderr.chain(consumeStringInputStream), _SCHEDULE_TIMEOUT,
           "waiting for the last stderr line from process $name");
     });
   }
 
   /// Writes [line] to the process as stdin.
   void writeLine(String line) {
-    _schedule((_) => _process.transform((p) => p.stdin.writeString('$line\n')));
+    _schedule((_) => _process.then((p) => p.stdin.writeString('$line\n')));
   }
 
   /// Kills the process, and waits until it's dead.
   void kill() {
     _endScheduled = true;
     _schedule((_) {
       _endExpected = true;
       return _process.chain((p) {
         p.kill();
         return timeout(_exitCode, _SCHEDULE_TIMEOUT,
             "waiting for process $name to die");
       });
     });
   }
 
   /// Waits for the process to exit, and verifies that the exit code matches
   /// [expectedExitCode] (if given).
   void shouldExit([int expectedExitCode]) {
     _endScheduled = true;
     _schedule((_) {
       _endExpected = true;
       return timeout(_exitCode, _SCHEDULE_TIMEOUT,
-          "waiting for process $name to exit").transform((exitCode) {
+          "waiting for process $name to exit").then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     });
   }
 
   /// Prints the remaining data in the process's stdout and stderr streams.
   /// Prints nothing if the straems are empty.
   Future _printStreams() {
     Future printStream(String streamName, StringInputStream stream) {
-      return consumeStringInputStream(stream).transform((output) {
+      return consumeStringInputStream(stream).then((output) {
         if (output.isEmpty) return;
 
         print('\nProcess $name $streamName:');
         for (var line in output.trim().split("\n")) {
           print('| $line');
         }
         return;
       });
     }
 
@@ skipping 25 matching lines @@
       var server = new HttpServer();
       server.defaultRequestHandler = scheduledServer._awaitHandle;
       server.listen("127.0.0.1", 0);
       _scheduleCleanup((_) => server.close());
       return new Future.immediate(server);
     }));
     return scheduledServer;
   }
 
   /// The port on which the server is listening.
-  Future<int> get port => _server.transform((s) => s.port);
+  Future<int> get port => _server.then((s) => s.port);
 
   /// The base URL of the server, including its port.
   Future<Uri> get url =>
-    port.transform((p) => new Uri.fromString("http://localhost:$p"));
+    port.then((p) => new Uri.fromString("http://localhost:$p"));
 
   /// Assert that the next request has the given [method] and [path], and pass
   /// it to [handler] to handle. If [handler] returns a [Future], wait until
   /// it's completed to continue the schedule.
   void handle(String method, String path,
       Future handler(HttpRequest request, HttpResponse response)) {
     var handlerCompleter = new Completer<Function>();
     _scheduleValue((_) {
       var requestCompleteCompleter = new Completer();
       handlerCompleter.complete((request, response) {
@@ skipping 17 matching lines @@
     _ignored.add(new Pair(method, path));
 
   /// Raises an error complaining of an unexpected request.
   void _awaitHandle(HttpRequest request, HttpResponse response) {
     if (_ignored.contains(new Pair(request.method, request.path))) return;
     var future = timeout(new Future.immediate(null).chain((_) {
       if (_handlers.isEmpty) {
         fail('Unexpected ${request.method} request to ${request.path}.');
       }
       return _handlers.removeFirst();
-    }).transform((handler) {
+    }).then((handler) {
       handler(request, response);
     }), _SCHEDULE_TIMEOUT, "waiting for a handler for ${request.method} "
         "${request.path}");
     expect(future, completes);
   }
 }
 
 /// Takes a simple data structure (composed of [Map]s, [List]s, scalar objects,
 /// and [Future]s) and recursively resolves all the [Future]s contained within.
 /// Completes with the fully resolved structure.
 Future _awaitObject(object) {
   // Unroll nested futures.
-  if (object is Future) return object.chain(_awaitObject);
-  if (object is Collection) return Futures.wait(object.map(_awaitObject));
+  if (object is Future) return object.then(_awaitObject);
+  if (object is Collection) {
+    return Futures.wait(object.mappedBy(_awaitObject).toList());
+  }
   if (object is! Map) return new Future.immediate(object);
 
   var pairs = <Future<Pair>>[];
   object.forEach((key, value) {
     pairs.add(_awaitObject(value)
-        .transform((resolved) => new Pair(key, resolved)));
+        .then((resolved) => new Pair(key, resolved)));
   });
-  return Futures.wait(pairs).transform((resolvedPairs) {
+  return Futures.wait(pairs).then((resolvedPairs) {
     var map = {};
     for (var pair in resolvedPairs) {
       map[pair.first] = pair.last;
     }
     return map;
   });
 }
 
 /// Schedules a callback to be called as part of the test case.
 void _schedule(_ScheduledEvent event) {
@@ skipping 28 matching lines @@
 
 /// Like [expect], but for [Future]s that complete as part of the scheduled
 /// test. This is necessary to ensure that the exception thrown by the
 /// expectation failing is handled by the scheduler.
 ///
 /// Note that [matcher] matches against the completed value of [actual], so
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
-    return actual.transform((value) {
+    return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }