Make pub handle missing git more gracefully.

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 57 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, Pattern output, int exitCode = 0]) {
+void runPub([List<String> args, Pattern output, Pattern error,
+    int exitCode = 0]) {
   var createdSandboxDir;
 
   var asyncDone = expectAsync0(() {});
 
   deleteSandboxIfCreated(onDeleted()) {
     _scheduledBeforePub = null;
     _scheduledAfterPub = null;
     if (createdSandboxDir != null) {
       deleteDir(createdSandboxDir).then((_) => onDeleted());
     } else {
@@ skipping 12 matching lines @@
     // TODO(rnystrom): Hack in the cache directory path. Should pass this
     // in using environment var once #752 is done.
     args.add('--cachedir=${pathInSandbox(cachePath)}');
 
     // TODO(rnystrom): Hack in the SDK path. Should pass this in using
     // environment var once #752 is done.
     args.add('--sdkdir=${pathInSandbox(sdkPath)}');
 
     return _runPub(args, pathInSandbox(appPath));
   }).chain((result) {
-    Expect.equals(result.stderr.length, 0,
-        'Did not expect any output on stderr, and got:\n' +
-        Strings.join(result.stderr, '\n'));
+    _validateOutput(output, result.stdout);
+    _validateOutput(error, result.stderr);
 
     Expect.equals(result.exitCode, exitCode,
         'Pub returned exit code ${result.exitCode}, expected $exitCode.');
 
-    _validateOutput(output, result.stdout);
-
     return _runScheduled(createdSandboxDir, _scheduledAfterPub);
   });
 
   future.then((_) {
     deleteSandboxIfCreated(asyncDone);
   });
 
   future.handleException((error) {
     // If an error occurs during testing, delete the sandbox, throw the error so
     // that the test framework sees it, then finally call asyncDone so that the
     // test framework knows we're done doing asynchronous stuff.
     deleteSandboxIfCreated(() {
       guardAsync(() { throw error; }, asyncDone);
     });
     return true;
   });
 }
 
+
+/**
+ * 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).
+ */
+void withGit(void callback()) {
+  isGitInstalled.then(expectAsync1((installed) {
+    if (installed || Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
+      callback();
+    }
+  }));
+}
+
 Future<Directory> _setUpSandbox() {
   return createTempDir('pub-test-sandbox-');
 }
 
 _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
   var future = Futures.wait(scheduled.map((event) => event(parentDir)));
   scheduled.clear();
   return future;
 }
@@ skipping 15 matching lines @@
   return runProcess(dartBin, args, workingDir);
 }
 
 /**
  * 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(Pattern expected, List<String> actual) {
+  if (expected == null) return;
+
   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
@@ skipping 202 matching lines @@
   _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);
 }