Don't implicitly run "pub get".

test/test_pub.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.
 
 /// 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 336 matching lines @@
       warning: warning, exitCode: exitCode);
 }
 
 /// Schedules starting the "pub [global] run" process and validates the
 /// expected startup output.
 ///
 /// If [global] is `true`, this invokes "pub global run", otherwise it does
 /// "pub run".
 ///
 /// Returns the `pub run` process.
-ScheduledProcess pubRun({bool shouldGetFirst: false, bool global: false,
-    Iterable<String> args}) {
+ScheduledProcess pubRun({bool global: false, Iterable<String> args}) {
   var pubArgs = global ? ["global", "run"] : ["run"];
   pubArgs.addAll(args);
   var pub = startPub(args: pubArgs);
 
-  if (shouldGetFirst) {
-    pub.stdout.expect(consumeThrough(anyOf([
-      "Got dependencies!",
-      matches(new RegExp(r"^Changed \d+ dependenc"))
-    ])));
-  }
-
   // Loading sources and transformers isn't normally printed, but the pub test
   // infrastructure runs pub in verbose mode, which enables this.
   pub.stdout.expect(consumeWhile(startsWith("Loading")));
 
   return pub;
 }
 
 /// Defines an integration test.
 ///
 /// The [body] should schedule a series of operations which will be run
@@ skipping 121 matching lines @@
 /// Gets the absolute path to [relPath], which is a relative path in the test
 /// sandbox.
 String _pathInSandbox(String relPath) {
   return p.join(p.absolute(sandboxDir), relPath);
 }
 
 /// Gets the environment variables used to run pub in a test context.
 Future<Map> getPubTestEnvironment([String tokenEndpoint]) async {
   var environment = {};
   environment['_PUB_TESTING'] = 'true';
-  environment['PUB_CACHE'] = _pathInSandbox(cachePath);
+  environment['PUB_CACHE'] = await schedule(() => _pathInSandbox(cachePath));
 
   // Ensure a known SDK version is set for the tests that rely on that.
   environment['_PUB_TEST_SDK_VERSION'] = "0.1.2+3";
 
   if (tokenEndpoint != null) {
     environment['_PUB_TEST_TOKEN_ENDPOINT'] = tokenEndpoint.toString();
   }
 
   if (_hasServer) {
-    return port.then((p) {
-      environment['PUB_HOSTED_URL'] = "http://localhost:$p";
-      return environment;
-    });
+    environment['PUB_HOSTED_URL'] = "http://localhost:${await port}";
   }
 
   return environment;
 }
 
 /// Starts a Pub process and returns a [ScheduledProcess] that supports
 /// interaction with that process.
 ///
 /// Any futures in [args] will be resolved before the process is started.
 ///
 /// If [environment] is given, any keys in it will override the environment
 /// variables passed to the spawned process.
 ScheduledProcess startPub({List args, Future<String> tokenEndpoint,
     Map<String, String> environment}) {
-  ensureDir(_pathInSandbox(appPath));
+  schedule(() {
+    ensureDir(_pathInSandbox(appPath));
+  }, "ensuring $appPath exists");
 
   // Find a Dart executable we can use to spawn. Use the same one that was
   // used to run this script itself.
   var dartBin = Platform.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 = p.absolute(dartBin);
   }
@@ skipping 14 matching lines @@
 
   if (tokenEndpoint == null) tokenEndpoint = new Future.value();
   var environmentFuture = tokenEndpoint
       .then((tokenEndpoint) => getPubTestEnvironment(tokenEndpoint))
       .then((pubEnvironment) {
     if (environment != null) pubEnvironment.addAll(environment);
     return pubEnvironment;
   });
 
   return new PubProcess.start(dartBin, dartArgs, environment: environmentFuture,
-      workingDirectory: _pathInSandbox(appPath),
+      workingDirectory: schedule(() => _pathInSandbox(appPath)),
       description: args.isEmpty ? 'pub' : 'pub ${args.first}');
 }
 
 /// A subclass of [ScheduledProcess] that parses pub's verbose logging output
 /// and makes [stdout] and [stderr] work as though pub weren't running in
 /// verbose mode.
 class PubProcess extends ScheduledProcess {
   Stream<Pair<log.Level, String>> _log;
   Stream<String> _stdout;
   Stream<String> _stderr;
@@ skipping 100 matching lines @@
     Map<String, String> hosted}) {
   // Start the server so we know what port to use in the cache directory name.
   serveNoPackages();
 
   // Create the package in the hosted cache.
   d.hostedCache([
     d.dir("$package-$version", contents)
   ]).create();
 
   // Write the lockfile to the global cache.
-  var sources = new SourceRegistry();
-  sources.register(new HostedSource());
-  sources.register(new PathSource());
+  var cache = new SystemCache.withSources(
+      rootDir: p.join(sandboxDir, cachePath));
 
-  var lockFile = _createLockFile(sources, pkg: pkg, hosted: hosted);
+  var lockFile = _createLockFile(cache.sources, pkg: pkg, hosted: hosted);
 
   // Add the root package to the lockfile.
   var id = new PackageId(package, "hosted", new Version.parse(version),
       package);
   lockFile = lockFile.setPackage(id);
 
   d.dir(cachePath, [
     d.dir("global_packages", [
-      d.file("$package.lock", lockFile.serialize(null))
+      d.dir(package, [
+        d.file("pubspec.lock", lockFile.serialize(null)),
+        d.file(".packages", lockFile.packagesFile())
+      ])
     ])
   ]).create();
 }
 
 /// Creates a lock file for [package] without running `pub get`.
 ///
 /// [sandbox] is a list of path dependencies to be found in the sandbox
 /// directory. [pkg] is a list of packages in the Dart repo's "pkg" directory;
 /// each package listed here and all its dependencies will be linked to the
 /// version in the Dart repo.
 ///
 /// [hosted] is a list of package names to version strings for dependencies on
 /// hosted packages.
 void createLockFile(String package, {Iterable<String> sandbox,
     Iterable<String> pkg, Map<String, String> hosted}) {
-  var sources = new SourceRegistry();
-  sources.register(new HostedSource());
-  sources.register(new PathSource());
+  var cache = new SystemCache.withSources(
+      rootDir: p.join(sandboxDir, cachePath));
 
-  var lockFile = _createLockFile(sources,
+  var lockFile = _createLockFile(cache.sources,
       sandbox: sandbox, pkg: pkg, hosted: hosted);
 
-  d.file(p.join(package, 'pubspec.lock'), lockFile.serialize(null)).create();
+  d.dir(package, [
+    d.file('pubspec.lock', lockFile.serialize(null)),
+    d.file('.packages', lockFile.packagesFile(package))
+  ]).create();
 }
 
 /// Creates a lock file for [package] without running `pub get`.
 ///
 /// [sandbox] is a list of path dependencies to be found in the sandbox
 /// directory. [pkg] is a list of packages in the Dart repo's "pkg" directory;
 /// each package listed here and all its dependencies will be linked to the
 /// version in the Dart repo.
 ///
 /// [hosted] is a list of package names to version strings for dependencies on
@@ skipping 264 matching lines @@
         _lastMatcher.matches(item.last, matchState);
   }
 
   Description describe(Description description) {
     return description.addAll("(", ", ", ")", [_firstMatcher, _lastMatcher]);
   }
 }
 
 /// A [StreamMatcher] that matches multiple lines of output.
 StreamMatcher emitsLines(String output) => inOrder(output.split("\n"));