Auto-reinstall broken packages in the system cache.

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 81 matching lines @@
 /// A future that will complete to the port used for the current server.
 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((_) {
+  schedule((_) {
     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;
@@ skipping 57 matching lines @@
     _servedPackages = <String, Map<String, String>>{};
     _servedPackageDir = dir('packages', []);
     serve([_servedPackageDir]);
 
     _scheduleCleanup((_) {
       _servedPackages = null;
       _servedPackageDir = null;
     });
   }
 
-  _schedule((_) {
+  schedule((_) {
     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();
@@ skipping 165 matching lines @@
       contents.add(packageCacheDir(name, version));
     }
   });
   return dir(cachePath, [
     dir('hosted', [
       async(port.then((p) => dir('localhost%58$p', contents)))
     ])
   ]);
 }
 
+/// Describes the directory in the system cache where the package [name] at
+/// [version] is stored when installed from the mock package server.
+Future<String> hostedCacheDir(String name, String version) {
+  return port.then((p) {
+    return path.join(cachePath, "hosted", "localhost%58$p", "$name-$version");
+  });
+}
+
 /// 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,
      DateTime expiration}) {
   return async(server.url.then((url) {
     return dir(cachePath, [
@@ skipping 153 matching lines @@
   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) {
+  schedule((sandboxDir) {
     return _doPub(runProcess, sandboxDir, args, tokenEndpoint).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.');
       }
@@ skipping 97 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((_) {
+  schedule((_) {
     return gitlib.isInstalled.then((installed) {
       if (!installed &&
           !Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
         _abortScheduled = true;
       }
       return null;
     });
   });
 }
 
@@ skipping 130 matching lines @@
   Future delete(String dir);
 
   /// Loads the file at [path] from within this descriptor. If [path] is empty,
   /// loads the contents of the descriptor itself.
   ByteStream load(List<String> path);
 
   /// Schedules the directory to be created before Pub is run with
   /// [schedulePub]. The directory will be created relative to the sandbox
   /// directory.
   // TODO(nweiz): Use implicit closurization once issue 2984 is fixed.
-  void scheduleCreate() => _schedule((dir) => this.create(dir));
+  void scheduleCreate() => schedule((dir) => this.create(dir));
 
   /// Schedules the file or directory to be deleted recursively.
-  void scheduleDelete() => _schedule((dir) => this.delete(dir));
+  void scheduleDelete() => schedule((dir) => this.delete(dir));
 
   /// Schedules the directory to be validated after Pub is run with
   /// [schedulePub]. The directory will be validated relative to the sandbox
   /// directory.
-  void scheduleValidate() => _schedule((parentDir) => validate(parentDir.path));
+  void scheduleValidate() => schedule((parentDir) => validate(parentDir.path));
 
   /// Asserts that the name of the descriptor is a [String] and returns it.
   String get _stringName {
     if (name is String) return name;
     throw 'Pattern $name must be a string.';
   }
 
   /// Validates that at least one file in [dir] matching [name] is valid
   /// according to [validate]. [validate] should throw or complete to an
   /// exception if the input path is invalid.
@@ skipping 205 matching lines @@
 
   /// Commits any changes to the Git repository.
   Future commit(parentDir) {
     return _runGitCommands(parentDir, [
       ['add', '.'],
       ['commit', '-m', 'update']
     ]);
   }
 
   /// Schedules changes to be committed to the Git repository.
-  void scheduleCommit() => _schedule((dir) => this.commit(dir));
+  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).then((rootDir) {
         return _runGit(['rev-parse', ref], rootDir);
       }).then((output) => output[0]);
     });
   }
 
   /// Schedule a Git command to run in this repository.
   void scheduleGit(List<String> args) {
-    _schedule((parentDir) {
+    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);
@@ skipping 228 matching lines @@
       var stderrPair = streamWithSubscription(stderrTee.last);
       _stderr = stderrPair.first;
       _stderrSubscription = stderrPair.last;
 
       return new Pair(stdoutTee.first, stderrTee.first);
     });
 
     _stdoutLines = pairFuture.then((pair) => pair.first.toList());
     _stderrLines = pairFuture.then((pair) => pair.last.toList());
 
-    _schedule((_) {
+    schedule((_) {
       if (!_endScheduled) {
         throw new StateError("Scheduled process $name must have shouldExit() "
             "or kill() called before the test is run.");
       }
 
       process.then((p) => p.exitCode).then((exitCode) {
         if (_endExpected) {
           _exitCode = exitCode;
           _exitCodeCompleter.complete(exitCode);
           return;
@@ skipping 81 matching lines @@
     return _scheduleValue((_) {
       return timeout(_stderrFuture.then((stream) => stream.toList())
               .then((lines) => lines.join("\n")),
           _SCHEDULE_TIMEOUT,
           "waiting for the last stderr line from process $name");
     });
   }
 
   /// Writes [line] to the process as stdin.
   void writeLine(String line) {
-    _schedule((_) => _processFuture.then(
+    schedule((_) => _processFuture.then(
         (p) => p.stdin.add('$line\n'.charCodes)));
   }
 
   /// Kills the process, and waits until it's dead.
   void kill() {
     _endScheduled = true;
-    _schedule((_) {
+    schedule((_) {
       _endExpected = true;
       _process.kill();
       timeout(_exitCodeFuture, _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((_) {
+    schedule((_) {
       _endExpected = true;
       return timeout(_exitCodeFuture, _SCHEDULE_TIMEOUT,
           "waiting for process $name to exit").then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     });
   }
 
@@ skipping 117 matching lines @@
   return Future.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) {
+void schedule(_ScheduledEvent event) {
   if (_scheduled == null) _scheduled = [];
   _scheduled.add(event);
 }
 
 /// Like [_schedule], but pipes the return value of [event] to a returned
 /// [Future].
 Future _scheduleValue(_ScheduledEvent event) {
   var completer = new Completer();
-  _schedule((parentDir) {
+  schedule((parentDir) {
     chainToCompleter(event(parentDir), completer);
     return completer.future;
   });
   return completer.future;
 }
 
 /// Schedules a callback to be called after the test case has completed, even
 /// if it failed.
 void _scheduleCleanup(_ScheduledEvent event) {
   if (_scheduledCleanup == null) _scheduledCleanup = [];
   _scheduledCleanup.add(event);
 }
 
 /// Schedules a callback to be called after the test case has completed, but
 /// only if it failed.
 void _scheduleOnException(_ScheduledEvent event) {
   if (_scheduledOnException == null) _scheduledOnException = [];
   _scheduledOnException.add(event);
 }
 
 /// 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((_) {
+  schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }