Take Sam Elkhateeb's path for "path" dependencies and clean it up some.

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 13 matching lines @@
 import '../../lib/file_system.dart' as fs;
 import '../../pub/entrypoint.dart';
 // TODO(rnystrom): Using "gitlib" as the prefix here is ugly, but "git" collides
 // with the git descriptor method. Maybe we should try to clean up the top level
 // scope a bit?
 import '../../pub/git.dart' as gitlib;
 import '../../pub/git_source.dart';
 import '../../pub/hosted_source.dart';
 import '../../pub/http.dart';
 import '../../pub/io.dart';
+import '../../pub/path_source.dart';
 import '../../pub/sdk_source.dart';
 import '../../pub/system_cache.dart';
 import '../../pub/utils.dart';
 import '../../pub/validator.dart';
 import 'command_line_config.dart';
 
 /// This should be called at the top of a test file to set up an appropriate
 /// test configuration for the machine running the tests.
 initConfig() {
   // If we aren't running on the bots, use the human-friendly config.
@@ skipping 353 matching lines @@
       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 "path":
+        source = new PathSource();
+        break;
       case "sdk":
         source = new SdkSource();
         break;
       default:
         throw 'Unknown source "$sourceName"';
       }
 
       result[_packageName(sourceName, dependency[sourceName])] = dependency;
     }
     return result;
   });
 }
 
 /// Return the name for the package described by [description] and from
 /// [sourceName].
 String _packageName(String sourceName, description) {
   switch (sourceName) {
   case "git":
     var url = description is String ? description : description['url'];
     return basename(url.replaceFirst(new RegExp(r"(\.git)?/?$"), ""));
   case "hosted":
     if (description is String) return description;
     return description['name'];
+  case "path":
+    return basename(description);
   case "sdk":
     return description;
   default:
     return description;
   }
 }
 
+/// The full path to the created sandbox directory for an integration test.
+String get sandboxDir => _sandboxDir.path;
+Directory _sandboxDir;
+
 /// The path of the package cache directory used for tests. Relative to the
 /// sandbox directory.
 final String cachePath = "cache";
 
 /// The path of the mock SDK directory used for tests. Relative to the sandbox
 /// directory.
 final String sdkPath = "sdk";
 
 /// The path of the mock app directory used for tests. Relative to the sandbox
 /// directory.
@@ skipping 34 matching lines @@
 void solo_integration(String description, void body()) =>
   _integration(description, body, solo_test);
 
 void _integration(String description, void body(), [Function testFn]) {
   testFn(description, () {
     // Ensure the SDK version is always available.
     dir(sdkPath, [
       file('version', '0.1.2.3')
     ]).scheduleCreate();
 
+    _sandboxDir = createTempDir();
+
     // Schedule the test.
     body();
 
     // Run all of the scheduled tasks. If an error occurs, it will propagate
     // through the futures back up to here where we can hand it off to unittest.
     var asyncDone = expectAsync0(() {});
-    var sandboxDir = createTempDir();
-    return timeout(_runScheduled(sandboxDir, _scheduled),
+    return timeout(_runScheduled(_scheduled),
           _TIMEOUT, 'waiting for a test to complete').catchError((e) {
-      return _runScheduled(sandboxDir, _scheduledOnException).then((_) {
+      return _runScheduled(_scheduledOnException).then((_) {
         // Rethrow the original error so it keeps propagating.
         throw e;
       });
     }).whenComplete(() {
       // Clean up after ourselves. Do this first before reporting back to
       // unittest because it will advance to the next test immediately.
-      return _runScheduled(sandboxDir, _scheduledCleanup).then((_) {
+      return _runScheduled(_scheduledCleanup).then((_) {
         _scheduled = null;
         _scheduledCleanup = null;
         _scheduledOnException = null;
-        if (sandboxDir != null) return deleteDir(sandboxDir);
+        if (_sandboxDir != null) {
+          var dir = _sandboxDir;
+          _sandboxDir = null;
+          return deleteDir(dir);
+        }
       });
     }).then((_) {
       // If we got here, the test completed successfully so tell unittest so.
       asyncDone();
     }).catchError((e) {
       // If we got here, an error occurred. We will register it with unittest
       // directly so that the error message isn't wrapped in any matcher stuff.
       // We do this call last because it will cause unittest to *synchronously*
       // advance to the next test and run it.
       registerException(e.error, e.stackTrace);
     });
   });
 }
 
 /// 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 renaming (moving) the directory at [from] to [to], both of which
+/// are assumed to be relative to [sandboxDir].
+void scheduleRename(String from, String to) {
+  _schedule((sandboxDir) {
+    return renameDir(join(sandboxDir, from), join(sandboxDir, to));
+  });
+}
+
 /// 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).then((result) {
       var failures = [];
 
       _validateOutput(failures, 'stdout', output, result.stdout);
       _validateOutput(failures, 'stderr', error, result.stderr);
@@ skipping 50 matching lines @@
   expectLater(pub.nextLine(), equals('Publishing "test_pkg" 1.0.0:'));
   expectLater(pub.nextLine(), equals("|-- LICENSE"));
   expectLater(pub.nextLine(), equals("|-- lib"));
   expectLater(pub.nextLine(), equals("|   '-- test_pkg.dart"));
   expectLater(pub.nextLine(), equals("'-- pubspec.yaml"));
   expectLater(pub.nextLine(), equals(""));
 
   pub.writeLine("y");
 }
 
-
 /// 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 defer(() {
     ensureDir(pathInSandbox(appPath));
     return Future.wait([
       _awaitObject(args),
       tokenEndpoint == null ? new Future.immediate(null) : tokenEndpoint
@@ skipping 54 matching lines @@
 /// 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 _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
+Future _runScheduled(List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
   var iterator = scheduled.iterator;
 
   Future runNextEvent(_) {
     if (_abortScheduled || !iterator.moveNext()) {
       _abortScheduled = false;
       scheduled.clear();
       return new Future.immediate(null);
     }
 
-    var future = iterator.current(parentDir);
+    var future = iterator.current(_sandboxDir);
     if (future != null) {
       return future.then(runNextEvent);
     } else {
       return runNextEvent(null);
     }
   }
 
   return runNextEvent(null);
 }
 
@@ skipping 458 matching lines @@
       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 that contains the errors 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));
 
     return defer(() {
       var validator = fn(new Entrypoint(join(sandboxDir, appPath), cache));
       return validator.validate().then((_) {
         return new Pair(validator.errors, validator.warnings);
       });
@@ skipping 418 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);
     });
   });
 }