Commit Martin's patch for pub + lib_v2.

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;
 
@@ skipping 152 matching lines @@
       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.toList());
+        var versions = _servedPackages[name].keys.toList();
         _servedPackageDir.contents.addAll([
           file('$name.json',
               json.stringify({'versions': versions})),
           dir(name, [
             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')
@@ skipping 274 matching lines @@
       if (createdSandboxDir != null) return deleteDir(createdSandboxDir);
       return new Future.immediate(null);
     });
   }
 
   final future = _setUpSandbox().then((sandboxDir) {
     createdSandboxDir = sandboxDir;
     return _runScheduled(sandboxDir, _scheduled);
   });
 
-  future.catchError((error) {
+  future.catchError((e) {
     // 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)
         .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(e.error, e.stackTrace));
+    return true;
+  });
+
   timeout(future, _TIMEOUT, 'waiting for a test to complete')
       .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);
@@ skipping 51 matching lines @@
       _doPub(startProcess, sandboxDir, args, tokenEndpoint));
   return new ScheduledProcess("pub", process);
 }
 
 /// Like [startPub], but runs `pub lish` in particular with [server] used both
 /// as the OAuth2 server (with "/token" as the token endpoint) and as the
 /// package server.
 ///
 /// Any futures in [args] will be resolved before the process is started.
 ScheduledProcess startPubLish(ScheduledServer server, {List args}) {
-  var tokenEndpoint = server.url.transform((url) =>
+  var tokenEndpoint = server.url.then((url) =>
       url.resolve('/token').toString());
   if (args == null) args = [];
   args = flatten(['lish', '--server', tokenEndpoint, args]);
   return startPub(args: args, tokenEndpoint: tokenEndpoint);
 }
 
 /// Handles the beginning confirmation process for uploading a packages.
 /// Ensures that the right output is shown and then enters "y" to confirm the
 /// upload.
 void confirmPublish(ScheduledProcess pub) {
@@ skipping 13 matching lines @@
 /// Calls [fn] with appropriately modified arguments to run a pub process. [fn]
 /// should have the same signature as [startProcess], except that the returned
 /// [Future] may have a type other than [Process].
 Future _doPub(Function fn, sandboxDir, List args, Future<Uri> tokenEndpoint) {
   String pathInSandbox(path) => join(getFullPath(sandboxDir), path);
 
   return Futures.wait([
     ensureDir(pathInSandbox(appPath)),
     _awaitObject(args),
     tokenEndpoint == null ? new Future.immediate(null) : tokenEndpoint
-  ]).chain((results) {
+  ]).then((results) {
     var args = results[1];
     var tokenEndpoint = results[2];
     // Find a Dart executable we can use to spawn. Use the same one that was
     // used to run this script itself.
     var dartBin = new Options().executable;
 
     // If the executable looks like a path, get its full path. That way we
     // can still find it when we spawn it with a different working directory.
     if (dartBin.contains(Platform.pathSeparator)) {
       dartBin = new File(dartBin).fullPathSync();
@@ skipping 557 matching lines @@
 /// 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) {
+        .then((entrypoint) {
       var validator = fn(entrypoint);
       return validator.validate().then((_) {
         return new Pair(validator.errors, validator.warnings);
       });
     });
   });
 }
 
 /// A matcher that matches a Pair.
 Matcher pairOf(Matcher firstMatcher, Matcher lastMatcher) =>
@@ skipping 26 matching lines @@
 ///
 /// Before running the test, either [shouldExit] or [kill] must be called on
 /// this to ensure that the process terminates when expected.
 ///
 /// If the test fails, this will automatically print out any remaining stdout
 /// and stderr from the process to aid debugging.
 class ScheduledProcess {
   /// The name of the process. Used for error reporting.
   final String name;
 
-  /// The process that's scheduled to run.
-  final Future<Process> _process;
+  /// The process future that's scheduled to run.
+  Future<Process> _processFuture;
+
+  /// The process that's scheduled to run. It may be null.
+  Process _process;
+
+  /// The exit code of the scheduled program. It may be null.
+  int _exitCode;
 
   /// A [StringInputStream] wrapping the stdout of the process that's scheduled
   /// to run.
-  final Future<StringInputStream> _stdout;
+  final Future<StringInputStream> _stdoutFuture;
 
   /// A [StringInputStream] wrapping the stderr of the process that's scheduled
   /// to run.
-  final Future<StringInputStream> _stderr;
+  final Future<StringInputStream> _stderrFuture;
 
   /// The exit code of the process that's scheduled to run. This will naturally
   /// only complete once the process has terminated.
-  Future<int> get _exitCode => _exitCodeCompleter.future;
+  Future<int> get _exitCodeFuture => _exitCodeCompleter.future;
 
   /// The completer for [_exitCode].
   final Completer<int> _exitCodeCompleter = new Completer();
 
   /// 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.then((p) => new StringInputStream(p.stdout)),
-      _stderr = process.then((p) => new StringInputStream(p.stderr)) {
+    : _processFuture = process,
+      _stdoutFuture = process.then((p) => new StringInputStream(p.stdout)),
+      _stderrFuture = process.then((p) => new StringInputStream(p.stderr)) {
+    process.then((p) {
+      _process = p;
+    });
 
     _schedule((_) {
       if (!_endScheduled) {
         throw new StateError("Scheduled process $name must have shouldExit() "
             "or kill() called before the test is run.");
       }
 
-      return _process.then((p) {
+      return process.then((p) {
         p.onExit = (c) {
           if (_endExpected) {
+            _exitCode = c;
             _exitCodeCompleter.complete(c);
             return;
           }
 
           // Sleep for half a second in case _endExpected is set in the next
           // scheduled event.
           sleep(500).then((_) {
             if (_endExpected) {
               _exitCodeCompleter.complete(c);
               return;
             }
 
             _printStreams().then((_) {
               registerException(new ExpectException("Process $name ended "
                   "earlier than scheduled with exit code $c"));
             });
           });
         };
       });
     });
 
     _scheduleOnException((_) {
-      if (!_process.hasValue) return;
+      if (_process == null) return;
 
-      if (!_exitCode.hasValue) {
+      if (_exitCode == null) {
         print("\nKilling process $name prematurely.");
         _endExpected = true;
-        _process.value.kill();
+        _process.kill();
       }
 
       return _printStreams();
     });
 
     _scheduleCleanup((_) {
-      if (!_process.hasValue) return;
+      if (_process == null) return;
       // Ensure that the process is dead and we aren't waiting on any IO.
-      var process = _process.value;
-      process.kill();
-      process.stdout.close();
-      process.stderr.close();
+      _process.kill();
+      _process.stdout.close();
+      _process.stderr.close();
     });
   }
 
   /// Reads the next line of stdout from the process.
   Future<String> nextLine() {
     return _scheduleValue((_) {
-      return timeout(_stdout.chain((stream) => readLine(stream)),
+      return timeout(_stdoutFuture.then((stream) => readLine(stream)),
           _SCHEDULE_TIMEOUT,
           "waiting for the next stdout line from process $name");
     });
   }
 
   /// Reads the next line of stderr from the process.
   Future<String> nextErrLine() {
     return _scheduleValue((_) {
-      return timeout(_stderr.chain((stream) => readLine(stream)),
+      return timeout(_stderrFuture.then((stream) => readLine(stream)),
           _SCHEDULE_TIMEOUT,
           "waiting for the next stderr line from process $name");
     });
   }
 
   /// Reads the remaining stdout from the process. This should only be called
   /// after kill() or shouldExit().
   Future<String> remainingStdout() {
     if (!_endScheduled) {
       throw new StateError("remainingStdout() should only be called after "
           "kill() or shouldExit().");
     }
 
     return _scheduleValue((_) {
-      return timeout(_stdout.chain(consumeStringInputStream), _SCHEDULE_TIMEOUT,
+      return timeout(_stdoutFuture.then(consumeStringInputStream),
+          _SCHEDULE_TIMEOUT,
           "waiting for the last stdout line from process $name");
     });
   }
 
   /// Reads the remaining stderr from the process. This should only be called
   /// after kill() or shouldExit().
   Future<String> remainingStderr() {
     if (!_endScheduled) {
       throw new StateError("remainingStderr() should only be called after "
           "kill() or shouldExit().");
     }
 
     return _scheduleValue((_) {
-      return timeout(_stderr.chain(consumeStringInputStream), _SCHEDULE_TIMEOUT,
+      return timeout(_stderrFuture.then(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.then((p) => p.stdin.writeString('$line\n')));
+    _schedule((_) => _processFuture.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");
-      });
+      _process.kill();
+      timeout(_exitCodeCompleter.future, _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,
+      return timeout(_exitCodeCompleter.future, _SCHEDULE_TIMEOUT,
           "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).then((output) {
         if (output.isEmpty) return;
 
         print('\nProcess $name $streamName:');
         for (var line in output.trim().split("\n")) {
           print('| $line');
         }
         return;
       });
     }
 
-    return printStream('stdout', _stdout.value)
-        .chain((_) => printStream('stderr', _stderr.value));
+    return _stdoutFuture.then((stdout) {
+      return _stderrFuture.then((stderr) {
+        return printStream('stdout', stdout)
+            .then((_) => printStream('stderr', stderr));
+      });
+    });
   }
 }
 
 /// A class representing an [HttpServer] that's scheduled to run in the course
 /// of the test. This class allows the server's request handling to be
 /// scheduled synchronously. All operations on this class are scheduled.
 class ScheduledServer {
   /// The wrapped server.
   final Future<HttpServer> _server;
 
@@ skipping 50 matching lines @@
   }
 
   /// Ignore all requests with the given [method] and [path]. If one is
   /// received, don't respond to it.
   void ignore(String method, String path) =>
     _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((_) {
+    var future = timeout(new Future.immediate(null).then((_) {
       if (_handlers.isEmpty) {
         fail('Unexpected ${request.method} request to ${request.path}.');
       }
       return _handlers.removeFirst();
     }).then((handler) {
       handler(request, response);
     }), _SCHEDULE_TIMEOUT, "waiting for a handler for ${request.method} "
         "${request.path}");
     expect(future, completes);
   }
@@ skipping 63 matching lines @@
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }