Add a Pub source that checks packages out from Git.

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.
  */
@@ skipping 11 matching lines @@
 FileDescriptor file(String name, String contents) =>
     new FileDescriptor(name, contents);
 
 /**
  * Creates a new [DirectoryDescriptor] with [name] and [contents].
  */
 DirectoryDescriptor dir(String name, [List<Descriptor> contents]) =>
     new DirectoryDescriptor(name, contents);
 
 /**
+ * Creates a new [GitRepoDescriptor] with [name] and [contents].
+ */
+DirectoryDescriptor git(String name, [List<Descriptor> contents]) =>
+    new GitRepoDescriptor(name, contents);
+
+/**
  * 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";
@@ skipping 20 matching lines @@
  * The list of events that are scheduled to run after the sandbox directory has
  * been created but before Pub is run.
  */
 List<_ScheduledEvent> _scheduledBeforePub;
 
 /**
  * The list of events that are scheduled to run after Pub has been run.
  */
 List<_ScheduledEvent> _scheduledAfterPub;
 
-void runPub([List<String> args, String output, int exitCode = 0]) {
+void runPub([List<String> args, Pattern output, int exitCode = 0]) {
   var createdSandboxDir;
 
   var asyncDone = expectAsync0(() {});
 
   deleteSandboxIfCreated(onDeleted()) {
     _scheduledBeforePub = null;
     _scheduledAfterPub = null;
     if (createdSandboxDir != null) {
       deleteDir(createdSandboxDir).then((_) => onDeleted());
     } else {
@@ skipping 67 matching lines @@
   // Find the main pub entrypoint.
   final pubPath = fs.joinPaths(scriptDir, '../../pub/pub.dart');
 
   final args = ['--enable-type-checks', '--enable-asserts', pubPath];
   args.addAll(pubArgs);
 
   return runProcess(dartBin, args, workingDir);
 }
 
 /**
- * Compares the [actual] output from running pub with [expectedText]. Ignores
- * leading and trailing whitespace differences and tries to report the
- * offending difference in a nice way.
+ * Compares the [actual] output from running pub with [expected]. For [String]
+ * patterns, ignores leading and trailing whitespace differences and tries to
+ * report the offending difference in a nice way. For other [Pattern]s, just
+ * reports whether the output contained the pattern.
  */
-void _validateOutput(String expectedText, List<String> actual) {
+void _validateOutput(Pattern expected, List<String> actual) {
+  if (expected is String) return _validateOutputString(expected, actual);
+  var actualText = Strings.join(actual, "\n");
+  if (actualText.contains(expected)) return;
+  Expect.fail('Expected output to match "$expected", was:\n$actualText');
+}
+
+void _validateOutputString(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.
   expected.removeLast();
 
   final length = Math.min(expected.length, actual.length);
   for (var i = 0; i < length; i++) {
     if (expected[i].trim() != actual[i].trim()) {
@@ skipping 48 matching lines @@
    * Validates that this descriptor correctly matches the corresponding file
    * system entry within [dir]. Returns a [Future] that completes to `null` if
    * the entry is valid, or throws an error if it failed.
    */
   abstract Future validate(String dir);
 
   /**
    * Schedules the directory to be created before Pub is run with [runPub]. The
    * directory will be created relative to the sandbox directory.
    */
-  void scheduleCreate() => _scheduleBeforePub(create);
+  // TODO(nweiz): Use implicit closurization once issue 2984 is fixed.
+  void scheduleCreate() => _scheduleBeforePub((dir) => this.create(dir));
 
   /**
    * Schedules the directory to be validated after Pub is run with [runPub]. The
    * directory will be validated relative to the sandbox directory.
    */
   void scheduleValidate() =>
     _scheduleAfterPub((parentDir) => validate(parentDir.path));
 }
 
 /**
@@ skipping 82 matching lines @@
     // Validate each of the items in this directory.
     final entryFutures = contents.map(
         (entry) => entry.validate(join(path, name)));
 
     // If they are all valid, the directory is valid.
     return Futures.wait(entryFutures).transform((entries) => null);
   }
 }
 
 /**
+ * Describes a Git repository and its contents.
+ */
+class GitRepoDescriptor extends DirectoryDescriptor {
+  GitRepoDescriptor(String name, List<Descriptor> contents)
+  : super(name, contents);
+
+  /**
+   * Creates the Git repository and commits the contents.
+   */
+  Future<Directory> create(parentDir) {
+    var workingDir;
+    Future runGit(List<String> args) {
+      return runProcess('git', args, workingDir: workingDir.path).
+        transform((result) {
+          if (!result.success) throw "Error running git: ${result.stderr}";
+          return null;
+        });
+    }
+
+    return super.create(parentDir).chain((rootDir) {
+      workingDir = rootDir;
+      return runGit(['init']);
+    }).chain((_) => runGit(['add', '.']))
+      .chain((_) => runGit(['commit', '-m', 'initial commit']))
+      .transform((_) => workingDir);
+  }
+}
+
+/**
  * Schedules a callback to be called before Pub is run with [runPub].
  */
 void _scheduleBeforePub(_ScheduledEvent event) {
   if (_scheduledBeforePub == null) _scheduledBeforePub = [];
   _scheduledBeforePub.add(event);
 }
 
 /**
  * Schedules a callback to be called after Pub is run with [runPub].
  */
 void _scheduleAfterPub(_ScheduledEvent event) {
   if (_scheduledAfterPub == null) _scheduledAfterPub = [];
   _scheduledAfterPub.add(event);
 }