Reverting 7623

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, Pattern output, int exitCode = 0]) {
+void runPub([List<String> args, String 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 [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.
+ * 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.
  */
-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) {
+void _validateOutput(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.
    */
-  // TODO(nweiz): Use implicit closurization once issue 2984 is fixed.
-  void scheduleCreate() => _scheduleBeforePub((dir) => this.create(dir));
+  void scheduleCreate() => _scheduleBeforePub(create);
 
   /**
    * 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);
 }