Add a "pub global run" command.

sdk/lib/_internal/pub/test/test_pub.dart

 // Copyright (c) 2013, 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;
@@ skipping 207 matching lines @@
 Map<String, List<Map>> _servedPackages;
 
 /// Creates an HTTP server that replicates the structure of pub.dartlang.org.
 ///
 /// [pubspecs] is a list of unserialized pubspecs representing the packages to
 /// serve.
 ///
 /// If [replace] is false, subsequent calls to [servePackages] will add to the
 /// set of packages that are being served. Previous packages will continue to be
 /// served. Otherwise, the previous packages will no longer be served.
-void servePackages(List<Map> pubspecs, {bool replace: false}) {
+///
+/// If [contents] is given, its contents are added to every served
+/// package.
+void servePackages(List<Map> pubspecs, {bool replace: false,
+    Iterable<d.Descriptor> contents}) {
   if (_servedPackages == null || _servedPackageDir == null) {
     _servedPackages = <String, List<Map>>{};
     _servedApiPackageDir = d.dir('packages', []);
     _servedPackageDir = d.dir('packages', []);
     serve([
       d.dir('api', [_servedApiPackageDir]),
       _servedPackageDir
     ]);
 
     currentSchedule.onComplete.schedule(() {
       _servedPackages = null;
       _servedApiPackageDir = null;
       _servedPackageDir = null;
     }, 'cleaning up served packages');
   }
 
   schedule(() {
     return awaitObject(pubspecs).then((resolvedPubspecs) {
       if (replace) _servedPackages.clear();
 
-      for (var spec in resolvedPubspecs) {
-        var name = spec['name'];
-        var version = spec['version'];
+      for (var pubspec in resolvedPubspecs) {
+        var name = pubspec['name'];
+        var version = pubspec['version'];
         var versions = _servedPackages.putIfAbsent(name, () => []);
-        versions.add(spec);
+        versions.add(pubspec);
       }
 
       _servedApiPackageDir.contents.clear();
       _servedPackageDir.contents.clear();
       for (var name in _servedPackages.keys) {
         _servedApiPackageDir.contents.addAll([
           d.file('$name', JSON.encode({
             'name': name,
             'uploaders': ['nweiz@google.com'],
             'versions': _servedPackages[name].map(packageVersionApiMap).toList()
           })),
           d.dir(name, [
             d.dir('versions', _servedPackages[name].map((pubspec) {
               return d.file(pubspec['version'], JSON.encode(
                   packageVersionApiMap(pubspec, full: true)));
             }))
           ])
         ]);
 
         _servedPackageDir.contents.add(d.dir(name, [
           d.dir('versions', _servedPackages[name].map((pubspec) {
             var version = pubspec['version'];
-            return d.tar('$version.tar.gz', [
-              d.file('pubspec.yaml', JSON.encode(pubspec)),
-              d.libDir(name, '$name $version')
-            ]);
+
+            var archiveContents = [
+                d.file('pubspec.yaml', JSON.encode(pubspec)),
+                d.libDir(name, '$name $version')
+            ];
+
+            if (contents != null) {
+              archiveContents.addAll(contents);
+            }
+
+            return d.tar('$version.tar.gz', archiveContents);
           }))
         ]));
       }
     });
   }, 'initializing the package server');
 }
 
 /// Converts [value] into a YAML string.
 String yaml(value) => JSON.encode(value);
 
@@ skipping 80 matching lines @@
 void pubGet({Iterable<String> args, output, error, warning, int exitCode}) {
   pubCommand(RunCommand.get, args: args, output: output, error: error,
       warning: warning, exitCode: exitCode);
 }
 
 void pubUpgrade({Iterable<String> args, output, error, warning, int exitCode}) {
   pubCommand(RunCommand.upgrade, args: args, output: output, error: error,
       warning: warning, exitCode: exitCode);
 }
 
+/// Schedules starting the "pub [global] run" process and validates the
+/// expected startup output.
+///
+/// If [global] is `true`, this invokes "pub global run", otherwise it does
+/// "pub run".
+///
+/// if [transformers] is given, it should contain a list of transformer IDs
+/// (like "myapp/src/transformer") and this will validate that the output for
+/// loading those is shown.
+///
+/// Returns the `pub run` process.
+ScheduledProcess pubRun({bool global: false, Iterable<String> args,
+    Iterable<String> transformers}) {
+  var pubArgs = global ? ["global", "run"] : ["run"];
+  pubArgs.addAll(args);
+  var pub = startPub(args: pubArgs);
+
+  // This isn't normally printed, but the pub test infrastructure runs pub in
+  // verbose mode, which enables this.
+  pub.stdout.expect(startsWith("Loading source assets"));
+
+  if (transformers != null) {
+    for (var transformer in transformers) {
+      pub.stdout.expect(startsWith("Loading $transformer transformers"));

[nweiz, 2014/07/02 00:12:03]

Rather than requiring tests to pass in a list of transformers, maybe just do

    pub.stdout.expect(consumeWhile(startsWith("Loading ")));

[Bob Nystrom, 2014/07/02 18:00:53]

Done.

+    }
+  }
+  return pub;
+}
+
 /// Defines an integration test.
 ///
 /// The [body] should schedule a series of operations which will be run
 /// asynchronously.
 void integration(String description, void body()) =>
   _integration(description, body, test);
 
 /// Like [integration], but causes only this test to run.
 void solo_integration(String description, void body()) =>
   _integration(description, body, solo_test);
@@ skipping 273 matching lines @@
 void ensureGit() {
   if (Platform.operatingSystem == "windows") {
     currentSchedule.timeout = new Duration(seconds: 30);
   }
 
   if (!gitlib.isInstalled) {
     throw new Exception("Git must be installed to run this test.");
   }
 }
 
+/// Schedules activating a global package [package] without running
+/// "pub global activate".
+///
+/// This is useful because global packages must be hosted, but the test hosted
+/// server doesn't serve barback. The other parameters here follow
+/// [createLockFile].
+void makeGlobalPackage(String package, String version,
+    Iterable<d.Descriptor> contents, {Iterable<String> pkg,
+    Map<String, String> hosted}) {
+  // Start the server so we know what port to use in the cache directory name.
+  servePackages([]);
+
+  // Create the package in the hosted cache.
+  d.hostedCache([
+    d.dir("$package-$version", contents)
+  ]).create();
+
+  var lockFile = _createLockFile(pkg: pkg, hosted: hosted);
+
+  // Add the root package to the lockfile.
+  var id = new PackageId(package, "hosted", new Version.parse(version),
+      package);
+  lockFile.packages[package] = id;
+
+  // Write the lockfile to the global cache.
+  var sources = new SourceRegistry();
+  sources.register(new HostedSource());
+  sources.register(new PathSource());
+
+  d.dir(cachePath, [
+    d.dir("global_packages", [
+      d.file("$package.lock", lockFile.serialize(null, sources))
+    ])
+  ]).create();
+}
+
 /// Creates a lock file for [package] without running `pub get`.
 ///
 /// [sandbox] is a list of path dependencies to be found in the sandbox
 /// directory. [pkg] is a list of packages in the Dart repo's "pkg" directory;
 /// each package listed here and all its dependencies will be linked to the
 /// version in the Dart repo.
 ///
 /// [hosted] is a list of package names to version strings for dependencies on
 /// hosted packages.
 void createLockFile(String package, {Iterable<String> sandbox,
     Iterable<String> pkg, Map<String, String> hosted}) {
+  var lockFile = _createLockFile(sandbox: sandbox, pkg: pkg, hosted: hosted);
+
+  var sources = new SourceRegistry();
+  sources.register(new HostedSource());
+  sources.register(new PathSource());
+
+  d.file(path.join(package, 'pubspec.lock'),
+      lockFile.serialize(null, sources)).create();
+}
+
+/// Creates a lock file for [package] without running `pub get`.
+///
+/// [sandbox] is a list of path dependencies to be found in the sandbox
+/// directory. [pkg] is a list of packages in the Dart repo's "pkg" directory;
+/// each package listed here and all its dependencies will be linked to the
+/// version in the Dart repo.
+///
+/// [hosted] is a list of package names to version strings for dependencies on
+/// hosted packages.
+LockFile _createLockFile({Iterable<String> sandbox,
+Iterable<String> pkg, Map<String, String> hosted}) {
   var dependencies = {};
 
   if (sandbox != null) {
     for (var package in sandbox) {
       dependencies[package] = '../$package';
     }
   }
 
   if (pkg != null) {
     _addPackage(String package) {
       if (dependencies.containsKey(package)) return;
 
       var packagePath;
       if (package == 'barback') {
         if (_barbackDir == null) {
           throw new StateError("createLockFile() can only create a lock file "
-              "with a barback dependency within a withBarbackVersions() "
-              "block.");
+          "with a barback dependency within a withBarbackVersions() "
+          "block.");

[nweiz, 2014/07/02 00:12:03]

Fix this indentation.

[Bob Nystrom, 2014/07/02 18:00:53]

Done.

         }
         packagePath = _barbackDir;
       } else {
         packagePath = path.join(pkgPath, package);
       }
 
       dependencies[package] = packagePath;
       var pubspec = loadYaml(
-          readTextFile(path.join(packagePath, 'pubspec.yaml')));
+        readTextFile(path.join(packagePath, 'pubspec.yaml')));

[nweiz, 2014/07/02 00:12:02]

Also this indentation.

[Bob Nystrom, 2014/07/02 18:00:53]

Done.

       var packageDeps = pubspec['dependencies'];
       if (packageDeps == null) return;
       packageDeps.keys.forEach(_addPackage);
     }
 
     pkg.forEach(_addPackage);
   }
 
   var lockFile = new LockFile.empty();
   dependencies.forEach((name, dependencyPath) {
     var id = new PackageId(name, 'path', new Version(0, 0, 0), {
       'path': dependencyPath,
       'relative': path.isRelative(dependencyPath)
     });
     lockFile.packages[name] = id;
   });
 
   if (hosted != null) {
     hosted.forEach((name, version) {
       var id = new PackageId(name, 'hosted', new Version.parse(version), name);
       lockFile.packages[name] = id;
     });
   }
 
-  var sources = new SourceRegistry();
-  sources.register(new HostedSource());
-  sources.register(new PathSource());
-
-  d.file(path.join(package, 'pubspec.lock'),
-      lockFile.serialize(null, sources)).create();
+  return lockFile;
 }
 
 /// Uses [client] as the mock HTTP client for this test.
 ///
 /// Note that this will only affect HTTP requests made via http.dart in the
 /// parent process.
 void useMockClient(MockClient client) {
   var oldInnerClient = httpClient.inner;
   httpClient.inner = client;
   currentSchedule.onComplete.schedule(() {
@@ skipping 171 matching lines @@
         _lastMatcher.matches(item.last, matchState);
   }
 
   Description describe(Description description) {
     return description.addAll("(", ", ", ")", [_firstMatcher, _lastMatcher]);
   }
 }
 
 /// A [StreamMatcher] that matches multiple lines of output.
 StreamMatcher emitsLines(String output) => inOrder(output.split("\n"));