Allow the Git source to depend on a specific revision.

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 16 matching lines @@
 FileDescriptor file(Pattern name, String contents) =>
     new FileDescriptor(name, contents);
 
 /**
  * Creates a new [DirectoryDescriptor] with [name] and [contents].
  */
 DirectoryDescriptor dir(Pattern name, [List<Descriptor> contents]) =>
     new DirectoryDescriptor(name, contents);
 
 /**
+ * Creates a new [FutureDescriptor] wrapping [future].
+ */
+FutureDescriptor async(Future<Descriptor> future) =>
+    new FutureDescriptor(future);
+
+/**
  * Creates a new [GitRepoDescriptor] with [name] and [contents].
  */
-DirectoryDescriptor git(Pattern name, [List<Descriptor> contents]) =>
+GitRepoDescriptor git(Pattern name, [List<Descriptor> contents]) =>
     new GitRepoDescriptor(name, contents);
 
 /**
  * Creates a new [TarFileDescriptor] with [name] and [contents].
  */
 TarFileDescriptor tar(Pattern name, [List<Descriptor> contents]) =>
     new TarFileDescriptor(name, contents);
 
 /**
  * Creates an HTTP server to serve [contents] as static files. This server will
@@ skipping 112 matching lines @@
  */
 List<_ScheduledEvent> _scheduled;
 
 /**
  * The list of events that are scheduled to run after the test case, even if it
  * failed.
  */
 List<_ScheduledEvent> _scheduledCleanup;
 
 /**
+ * Set to true when the current batch of scheduled events should be aborted.
+ */
+bool _abortScheduled = false;
+
+/**
  * Runs all the scheduled events for a test case. This should only be called
  * once per test case.
  */
 void run() {
   var createdSandboxDir;
 
   var asyncDone = expectAsync0(() {});
 
   Future cleanup() {
     return _runScheduled(createdSandboxDir, _scheduledCleanup).chain((_) {
@@ skipping 69 matching lines @@
  * A shorthand for [schedulePub] and [run] when no validation needs to be done
  * after Pub has been run.
  */
 void runPub([List<String> args, Pattern output, Pattern error,
     int exitCode = 0]) {
   schedulePub(args, output, error, exitCode);
   run();
 }
 
 /**
- * Wraps a test that needs git in order to run. This validates that the test is
- * running on a builbot 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).
+ * 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 withGit(void callback()) {
-  isGitInstalled.then(expectAsync1((installed) {
-    if (installed || Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
-      callback();
-    }
-  }));
+void ensureGit() {
+  _schedule((_) {
+    return isGitInstalled.transform((installed) {
+      if (!installed &&
+          !Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
+        _abortScheduled = true;
+      }
+      return null;
+    });
+  });
 }
 
 Future<Directory> _setUpSandbox() {
   return createTempDir('pub-test-sandbox-');
 }
 
 Future _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
   var iterator = scheduled.iterator();
 
   Future runNextEvent([_]) {
-    if (!iterator.hasNext()) {
+    if (_abortScheduled || !iterator.hasNext()) {
+      _abortScheduled = false;
       scheduled.clear();
       return new Future.immediate(null);
     }
 
     var future = iterator.next()(parentDir);
     if (future != null) {
       return future.chain(runNextEvent);
     } else {
       return runNextEvent();
     }
@@ skipping 300 matching lines @@
       if (descriptor.name == path[0]) {
         return descriptor.load(path.getRange(1, path.length - 1));
       }
     }
 
     throw "Directory $name doesn't contain ${Strings.join(path, '/')}.";
   }
 }
 
 /**
+ * Wraps a [Future] that will complete to a [Descriptor] and makes it behave
+ * like a concrete [Descriptor]. This is necessary when the contents of the
+ * descriptor depends on information that's not available until part of the test
+ * run is completed.
+ */
+class FutureDescriptor extends Descriptor {
+  Future<Descriptor> _future;
+
+  FutureDescriptor(this._future) : super('<unknown>');
+
+  Future create(dir) => _future.chain((desc) => desc.create(dir));
+
+  Future validate(dir) => _future.chain((desc) => desc.validate(dir));
+
+  Future delete(dir) => _future.chain((desc) => desc.delete(dir));
+
+  InputStream load(List<String> path) {
+    var resultStream = new ListInputStream();
+    _future.then((desc) => pipeInputToInput(desc.load(path), resultStream));
+    return resultStream;
+  }
+}
+
+/**
  * Describes a Git repository and its contents.
  */
 class GitRepoDescriptor extends DirectoryDescriptor {
   GitRepoDescriptor(Pattern name, List<Descriptor> contents)
   : super(name, contents);
 
   /**
    * Creates the Git repository and commits the contents.
    */
   Future<Directory> create(parentDir) {
@@ skipping 19 matching lines @@
       workingDir = rootDir;
       return runGit(['add', '.']);
     }).chain((_) => runGit(['commit', '-m', 'update']));
   }
 
   /**
    * Schedules changes to be committed to the Git repository.
    */
   void scheduleCommit() => _schedule((dir) => this.commit(dir));
 
-  Future _runGit(List<String> args, Directory workingDir) {
+  /**
+   * 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) {
+    var completer = new Completer<String>();
+    // TODO(nweiz): inline this once issue 3197 is fixed
+    var superCreate = super.create;
+    _schedule((parentDir) {
+      return superCreate(parentDir).chain((rootDir) {
+        return _runGit(['rev-parse', ref], rootDir);
+      }).transform((output) {
+        completer.complete(output[0]);
+        return null;
+      });
+    });
+    return completer.future;
+  }
+
+  Future<String> _runGit(List<String> args, Directory workingDir) {
     return runProcess('git', args, workingDir: workingDir.path).
       transform((result) {
         if (!result.success) throw "Error running git: ${result.stderr}";
-        return null;
+        return result.stdout;
       });
   }
 }
 
 /**
  * Describes a gzipped tar file and its contents.
  */
 class TarFileDescriptor extends Descriptor {
   final List<Descriptor> contents;
 
@@ skipping 65 matching lines @@
 }
 
 /**
  * Schedules a callback to be called after Pub is run with [runPub], even if it
  * fails.
  */
 void _scheduleCleanup(_ScheduledEvent event) {
   if (_scheduledCleanup == null) _scheduledCleanup = [];
   _scheduledCleanup.add(event);
 }