Add numerous features to the Pub test infrastructure.

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');
 
 #import('dart:io');
 #import('dart:uri');
 
 #import('../../../lib/unittest/unittest.dart');
 #import('../../lib/file_system.dart', prefix: 'fs');
 #import('../../pub/io.dart');
+#import('../../pub/utils.dart');
 #import('../../pub/yaml/yaml.dart');
 
 /**
  * Creates a new [FileDescriptor] with [name] and [contents].
  */
-FileDescriptor file(String name, String contents) =>
+FileDescriptor file(Pattern name, String contents) =>
     new FileDescriptor(name, contents);
 
 /**
  * Creates a new [DirectoryDescriptor] with [name] and [contents].
  */
-DirectoryDescriptor dir(String name, [List<Descriptor> contents]) =>
+DirectoryDescriptor dir(Pattern name, [List<Descriptor> contents]) =>
     new DirectoryDescriptor(name, contents);
 
 /**
  * Creates a new [GitRepoDescriptor] with [name] and [contents].
  */
-DirectoryDescriptor git(String name, [List<Descriptor> contents]) =>
+DirectoryDescriptor git(Pattern name, [List<Descriptor> contents]) =>
     new GitRepoDescriptor(name, contents);
 
 /**
  * Creates a new [TarFileDescriptor] with [name] and [contents].
  */
-TarFileDescriptor tar(String name, [List<Descriptor> 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
  * exist only for the duration of the pub run.
  */
 void serve(String host, int port, [List<Descriptor> contents]) {
   var baseDir = dir("serve-dir", contents);
   if (host == 'localhost') {
     host = '127.0.0.1';
   }
 
-  _scheduleBeforePub((_) {
+  _schedule((_) {
     var server = new HttpServer();
     server.defaultRequestHandler = (request, response) {
       var path = request.uri.replaceFirst("/", "").split("/");
       var stream = baseDir.load(path);
       response.persistentConnection = false;
       if (stream == null) {
         response.statusCode = 404;
         response.outputStream.close();
         return;
       }
@@ skipping 72 matching lines @@
  */
 final String packagesPath = "$appPath/packages";
 
 /**
  * The type for callbacks that will be fired during [runPub]. Takes the sandbox
  * directory as a parameter.
  */
 typedef Future _ScheduledEvent(Directory parentDir);
 
 /**
- * The list of events that are scheduled to run after the sandbox directory has
- * been created but before Pub is run.
+ * The list of events that are scheduled to run as part of the test case.
  */
-List<_ScheduledEvent> _scheduledBeforePub;
+List<_ScheduledEvent> _scheduled;
 
 /**
- * The list of events that are scheduled to run after Pub has been run.
- */
-List<_ScheduledEvent> _scheduledAfterPub;
-
-/**
- * The list of events that are scheduled to run after Pub has been run, even if
- * it failed.
+ * The list of events that are scheduled to run after the test case, even if it
+ * failed.
  */
 List<_ScheduledEvent> _scheduledCleanup;
 
-void runPub([List<String> args, Pattern output, Pattern error,
-    int exitCode = 0]) {
+/**
+ * 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((_) {
-      _scheduledBeforePub = null;
-      _scheduledAfterPub = null;
+      _scheduled = null;
       if (createdSandboxDir != null) return deleteDir(createdSandboxDir);
       return new Future.immediate(null);
     });
   }
 
-  String pathInSandbox(path) => join(getFullPath(createdSandboxDir), path);
-
   final future = _setUpSandbox().chain((sandboxDir) {
     createdSandboxDir = sandboxDir;
-    return _runScheduled(sandboxDir, _scheduledBeforePub);
-  }).chain((_) {
-    return ensureDir(pathInSandbox(appPath));
-  }).chain((_) {
-    // 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), pipeStdout: output == null,
-        pipeStderr: error == null);
-  }).chain((result) {
-    _validateOutput(output, result.stdout);
-    _validateOutput(error, result.stderr);
-
-    Expect.equals(result.exitCode, exitCode,
-        'Pub returned exit code ${result.exitCode}, expected $exitCode.');
-
-    return _runScheduled(createdSandboxDir, _scheduledAfterPub);
+    return _runScheduled(sandboxDir, _scheduled);
   });
 
-  future.chain((_) => cleanup()).then((_) => 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.
     cleanup().then((_) {
       guardAsync(() { throw error; }, asyncDone);
     });
     return true;
   });
+
+  future.chain((_) => cleanup()).then((_) => asyncDone());
 }
 
+/**
+ * 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<String> args, Pattern output, Pattern error,
+    int exitCode = 0]) {
+  _schedule((sandboxDir) {
+    String pathInSandbox(path) => join(getFullPath(sandboxDir), path);
+
+    return ensureDir(pathInSandbox(appPath)).chain((_) {
+      // 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), pipeStdout: output == null,
+          pipeStderr: error == null);
+    }).transform((result) {
+      _validateOutput(output, result.stdout);
+      _validateOutput(error, result.stderr);
+
+      Expect.equals(result.exitCode, exitCode,
+          'Pub returned exit code ${result.exitCode}, expected $exitCode.');
+
+      return null;
+    });
+  });
+}
+
+/**
+ * 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).
  */
 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) {
+Future _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
-  var future = Futures.wait(scheduled.map((event) {
-    var subFuture = event(parentDir);
-    return subFuture == null ? new Future.immediate(null) : subFuture;
-  }));
-  scheduled.clear();
-  return future;
+  var iterator = scheduled.iterator();
+
+  Future runNextEvent([_]) {
+    if (!iterator.hasNext()) {
+      scheduled.clear();
+      return new Future.immediate(null);
+    }
+
+    var future = iterator.next()(parentDir);
+    if (future != null) {
+      return future.chain(runNextEvent);
+    } else {
+      return runNextEvent();
+    }
+  }
+
+  return runNextEvent();
 }
 
 Future<ProcessResult> _runPub(List<String> pubArgs, String workingDir,
     [bool pipeStdout=false, bool pipeStderr=false]) {
   // Find a dart executable we can use to run pub. Uses the one that the
   // test infrastructure uses. We are not using new Options.executable here
   // because that gets confused if you invoked Dart through a shell script.
   final scriptDir = new File(new Options().script).directorySync().path;
   final platform = Platform.operatingSystem;
   final dartBin = join(scriptDir, '../../../tools/testing/bin/$platform/dart');
@@ skipping 61 matching lines @@
   }
 }
 
 /**
  * Base class for [FileDescriptor] and [DirectoryDescriptor] so that a
  * directory can contain a heterogeneous collection of files and
  * subdirectories.
  */
 class Descriptor {
   /**
-   * The short name of this file or directory.
+   * The name of this file or directory. This must be a [String] if the fiel or
+   * directory is going to be created.
    */
-  final String name;
+  final Pattern name;
 
   Descriptor(this.name);
 
   /**
    * Creates the file or directory within [dir]. Returns a [Future] that is
    * completed after the creation is done.
    */
   abstract Future create(dir);
 
   /**
    * 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);
 
   /**
+   * Deletes the file or directory within [dir]. Returns a [Future] that is
+   * completed after the deletion is done.
+   */
+  abstract Future delete(String dir);
+
+  /**
    * Loads the file at [path] from within this descriptor. If [path] is empty,
    * loads the contents of the descriptor itself.
    */
   abstract InputStream load(List<String> path);
 
   /**
    * 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() => _schedule((dir) => this.create(dir));
+
+  /**
+   * Schedules the file or directory to be deleted recursively.
+   */
+  void scheduleDelete() => _schedule((dir) => this.delete(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));
+  void scheduleValidate() => _schedule((parentDir) => validate(parentDir.path));
+
+  /**
+   * Asserts that the name of the descriptor is a [String] and returns it.
+   */
+  String get _stringName() {
+    if (name is String) return name;
+    throw 'Pattern $name must be a string.';
+  }
+
+  /**
+   * Validates that at least one file in [dir] matching [name] is valid
+   * according to [validate]. [validate] should complete to an exception if the
+   * input path is invalid.
+   */
+  Future _validateOneMatch(String dir, Future validate(String path)) {
+    // Special-case strings to support multi-level names like "myapp/packages".
+    if (name is String) {
+      var path = join(dir, name);
+      return exists(path).chain((exists) {
+        if (!exists) Expect.fail('File $name in $dir not found.');
+        return validate(path);
+      });
+    }
+
+    return listDir(dir).chain((files) {
+      var matches = files.filter((file) => endsWithPattern(file, name));
+      if (matches.length == 0) {
+        Expect.fail('No files in $dir match pattern $name.');
+      }
+      if (matches.length == 1) return validate(matches[0]);
+
+      var failures = [];
+      var completer = new Completer();
+      for (var match in matches) {
+        var future = validate(match);
+
+        future.handleException((e) {
+          failures.add(e);
+          if (failures.length != matches.length) return true;
+
+          var error = new StringBuffer();
+          error.add("No files named $name in $dir were valid:\n");
+          for (var failure in failures) {
+            error.add("  ").add(failure).add("\n");
+          }
+          completer.completeException(new ExpectException(error.toString()));
+          return true;
+        });
+
+        future.then(completer.complete);
+      }
+      return completer.future;
+    });
+  }
 }
 
 /**
  * Describes a file. These are used both for setting up an expected directory
  * tree before running a test, and for validating that the file system matches
  * some expectations after running it.
  */
 class FileDescriptor extends Descriptor {
   /**
    * The text contents of the file.
    */
   final String contents;
 
-  FileDescriptor(String name, this.contents) : super(name);
+  FileDescriptor(Pattern name, this.contents) : super(name);
 
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
   Future<File> create(dir) {
-    return writeTextFile(join(dir, name), contents);
+    return writeTextFile(join(dir, _stringName), contents);
+  }
+
+  /**
+   * Deletes the file within [dir]. Returns a [Future] that is completed after
+   * the deletion is done.
+   */
+  Future delete(dir) {
+    return deleteFile(join(dir, _stringName));
   }
 
   /**
    * Validates that this file correctly matches the actual file at [path].
    */
   Future validate(String path) {
-    path = join(path, name);
-    return fileExists(path).chain((exists) {
-      if (!exists) Expect.fail('Expected file $path does not exist.');
-
-      return readTextFile(path).transform((text) {
+    return _validateOneMatch(path, (file) {
+      return readTextFile(file).transform((text) {
         if (text == contents) return null;
 
-        Expect.fail('File $path should contain:\n\n$contents\n\n'
+        Expect.fail('File $file should contain:\n\n$contents\n\n'
                     'but contained:\n\n$text');
       });
     });
   }
 
   /**
    * Loads the contents of the file.
    */
   InputStream load(List<String> path) {
     if (!path.isEmpty()) {
@@ skipping 11 matching lines @@
  * Describes a directory and its contents. These are used both for setting up
  * an expected directory tree before running a test, and for validating that
  * the file system matches some expectations after running it.
  */
 class DirectoryDescriptor extends Descriptor {
   /**
    * The files and directories contained in this directory.
    */
   final List<Descriptor> contents;
 
-  DirectoryDescriptor(String name, this.contents) : super(name);
+  DirectoryDescriptor(Pattern name, this.contents) : super(name);
 
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
   Future<Directory> create(parentDir) {
     final completer = new Completer<Directory>();
 
     // Create the directory.
-    createDir(join(parentDir, name)).then((dir) {
+    ensureDir(join(parentDir, _stringName)).then((dir) {
       if (contents == null) {
         completer.complete(dir);
       } else {
         // Recursively create all of its children.
         final childFutures = contents.map((child) => child.create(dir));
         Futures.wait(childFutures).then((_) {
           // Only complete once all of the children have been created too.
           completer.complete(dir);
         });
       }
     });
 
     return completer.future;
   }
 
   /**
+   * Deletes the directory within [dir]. Returns a [Future] that is completed
+   * after the deletion is done.
+   */
+  Future delete(dir) {
+    return deleteDir(join(dir, _stringName));
+  }
+
+  /**
    * Validates that the directory at [path] contains all of the expected
    * contents in this descriptor. Note that this does *not* check that the
    * directory doesn't contain other unexpected stuff, just that it *does*
    * contain the stuff we do expect.
    */
   Future validate(String path) {
-    // Validate each of the items in this directory.
-    final entryFutures = contents.map(
-        (entry) => entry.validate(join(path, name)));
+    return _validateOneMatch(path, (dir) {
+      // Validate each of the items in this directory.
+      final entryFutures = contents.map((entry) => entry.validate(dir));
 
-    // If they are all valid, the directory is valid.
-    return Futures.wait(entryFutures).transform((entries) => null);
+      // If they are all valid, the directory is valid.
+      return Futures.wait(entryFutures).transform((entries) => null);
+    });
   }
 
   /**
    * Loads [path] from within this directory.
    */
   InputStream load(List<String> path) {
     if (path.isEmpty()) {
       throw "Can't load the contents of $name: is a directory.";
     }
 
     for (var descriptor in contents) {
       if (descriptor.name == path[0]) {
         return descriptor.load(path.getRange(1, path.length - 1));
       }
     }
 
     throw "Directory $name doesn't contain ${Strings.join('/', path)}.";
   }
 }
 
 /**
  * Describes a Git repository and its contents.
  */
 class GitRepoDescriptor extends DirectoryDescriptor {
-  GitRepoDescriptor(String name, List<Descriptor> contents)
+  GitRepoDescriptor(Pattern 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;
-        });
-    }
+    Future runGit(List<String> args) => _runGit(args, workingDir);
 
     return super.create(parentDir).chain((rootDir) {
       workingDir = rootDir;
       return runGit(['init']);
     }).chain((_) => runGit(['add', '.']))
       .chain((_) => runGit(['commit', '-m', 'initial commit']))
       .transform((_) => workingDir);
   }
+
+  /**
+   * Commits any changes to the Git repository.
+   */
+  Future commit(parentDir) {

[Jennifer Messerly, 2012/07/03 02:03:10]

anyone using this yet?

[nweiz, 2012/07/03 18:04:49]

No, all these changes are going to be used in a future commit.

+    var workingDir;
+    Future runGit(List<String> args) => _runGit(args, workingDir);
+
+    return super.create(parentDir).chain((rootDir) {
+      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 runProcess('git', args, workingDir: workingDir.path).
+      transform((result) {
+        if (!result.success) throw "Error running git: ${result.stderr}";
+        return null;
+      });
+  }
 }
 
 /**
  * Describes a gzipped tar file and its contents.
  */
 class TarFileDescriptor extends Descriptor {
   final List<Descriptor> contents;
 
-  TarFileDescriptor(String name, this.contents)
+  TarFileDescriptor(Pattern name, this.contents)
   : super(name);
 
   /**
    * Creates the files and directories within this tar file, then archives them,
    * compresses them, and saves the result to [parentDir].
    */
   Future<File> create(parentDir) {
     var tempDir;
     return parentDir.createTemp().chain((_tempDir) {
       tempDir = _tempDir;
       return Futures.wait(contents.map((child) => child.create(tempDir)));
     }).chain((_) {
       var args = ["--directory", tempDir.path, "--create", "--gzip", "--file",
-          join(parentDir, name)];
+          join(parentDir, _stringName)];
       args.addAll(contents.map((child) => child.name));
       return runProcess("tar", args);
     }).chain((result) {
       if (!result.success) {
         throw "Failed to create tar file $name.\n"
             "STDERR: ${Strings.join(result.stderr, "\n")}";
       }
       return deleteDir(tempDir);
     }).transform((_) {
-      return new File(join(parentDir, name));
+      return new File(join(parentDir, _stringName));
     });
   }
 
   /**
    * Validates that the `.tar.gz` file at [path] contains the expected contents.
    */
   Future validate(String path) {
     throw "TODO(nweiz): implement this";
   }
 
@@ skipping 15 matching lines @@
     }).then((tar) {
       var sourceStream = tar.openInputStream();
       pipeInputToInput(
           sourceStream, sinkStream, onClosed: tempDir.deleteRecursively);
     });
     return sinkStream;
   }
 }
 
 /**
- * Schedules a callback to be called before Pub is run with [runPub].
+ * Schedules a callback to be called as part of the test case.
  */
-void _scheduleBeforePub(_ScheduledEvent event) {
-  if (_scheduledBeforePub == null) _scheduledBeforePub = [];
-  _scheduledBeforePub.add(event);
+void _schedule(_ScheduledEvent event) {
+  if (_scheduled == null) _scheduled = [];
+  _scheduled.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);
-}
-
-/**
  * 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);
 }