Properly serve descriptors containing URI-sensitive characters in pub.

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;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:http/testing.dart';
-import 'package:path/path.dart' as path;
+import 'package:path/path.dart' as p;
 import 'package:scheduled_test/scheduled_process.dart';
 import 'package:scheduled_test/scheduled_server.dart';
 import 'package:scheduled_test/scheduled_stream.dart';
 import 'package:scheduled_test/scheduled_test.dart' hide fail;
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:shelf/shelf_io.dart' as shelf_io;
 import 'package:unittest/compact_vm_config.dart';
 import 'package:yaml/yaml.dart';
 
 import '../lib/src/entrypoint.dart';
@@ skipping 70 matching lines @@
 /// third_party/pkg.
 final _barbackDeps = {
   new VersionConstraint.parse("<0.15.0"): {
     "source_maps": "0.9.4"
   }
 };
 
 /// Populates [_barbackVersions].
 Map<Version, String> _findBarbackVersions() {
   var versions = {};
-  var currentBarback = path.join(repoRoot, 'pkg', 'barback');
+  var currentBarback = p.join(repoRoot, 'pkg', 'barback');
   versions[new Pubspec.load(currentBarback, new SourceRegistry()).version] =
       currentBarback;
 
-  for (var dir in listDir(path.join(repoRoot, 'third_party', 'pkg'))) {
-    var basename = path.basename(dir);
+  for (var dir in listDir(p.join(repoRoot, 'third_party', 'pkg'))) {
+    var basename = p.basename(dir);
     if (!basename.startsWith('barback')) continue;
     versions[new Version.parse(split1(basename, '-').last)] = dir;
   }
 
   return versions;
 }
 
 /// Runs the tests in [callback] against all versions of barback in the repo
 /// that match [versionConstraint].
 ///
@@ skipping 10 matching lines @@
   }
 
   for (var version in validVersions) {
     group("with barback $version", () {
       setUp(() {
         _packageOverrides = {};
         _packageOverrides['barback'] = _barbackVersions[version];
         _barbackDeps.forEach((constraint, deps) {
           if (!constraint.allows(version)) return;
           deps.forEach((packageName, version) {
-            _packageOverrides[packageName] = path.join(
+            _packageOverrides[packageName] = p.join(
                 repoRoot, 'third_party', 'pkg', '$packageName-$version');
           });
         });
 
         currentSchedule.onComplete.schedule(() {
           _packageOverrides = null;
         });
       });
 
       callback();
@@ skipping 30 matching lines @@
 /// calls to [serve] replace the previous server.
 void serve([List<d.Descriptor> contents]) {
   var baseDir = d.dir("serve-dir", contents);
 
   _hasServer = true;
 
   schedule(() {
     return _closeServer().then((_) {
       return shelf_io.serve((request) {
         currentSchedule.heartbeat();
-        var path = request.url.path.replaceFirst("/", "");
+        var path = p.posix.fromUri(request.url.path.replaceFirst("/", ""));
         _requestedPaths.add(path);
 
         return validateStream(baseDir.load(path))
             .then((stream) => new shelf.Response.ok(stream))
             .catchError((error) {
           return new shelf.Response.notFound('File "$path" not found.');
         });
       }, 'localhost', 0).then((server) {
         _server = server;
         _portCompleter.complete(_server.port);
@@ skipping 19 matching lines @@
 bool _hasServer = false;
 
 /// Converts [value] into a YAML string.
 String yaml(value) => JSON.encode(value);
 
 /// The full path to the created sandbox directory for an integration test.
 String get sandboxDir => _sandboxDir;
 String _sandboxDir;
 
 /// The path to the Dart repo's packages.
-final String pkgPath = path.absolute(path.join(
-    path.dirname(Platform.executable),
-    '..', '..', '..', '..', 'pkg'));
+final String pkgPath = p.absolute(p.join(
+    p.dirname(Platform.executable),
+    '../../../../pkg'));
 
 /// The path of the package cache directory used for tests, relative to the
 /// sandbox directory.
 final String cachePath = "cache";
 
 /// The path of the mock app directory used for tests, relative to the sandbox
 /// directory.
 final String appPath = "myapp";
 
 /// The path of the packages directory in the mock app used for tests, relative
@@ skipping 123 matching lines @@
         'deleting the sandbox directory');
 
     // Schedule the test.
     body();
   });
 }
 
 /// Get the path to the root "pub/test" directory containing the pub
 /// tests.
 String get testDirectory =>
-  path.absolute(path.dirname(libraryPath('test_pub')));
+  p.absolute(p.dirname(libraryPath('test_pub')));
 
 /// Schedules renaming (moving) the directory at [from] to [to], both of which
 /// are assumed to be relative to [sandboxDir].
 void scheduleRename(String from, String to) {
   schedule(
       () => renameDir(
-          path.join(sandboxDir, from),
-          path.join(sandboxDir, to)),
+          p.join(sandboxDir, from),
+          p.join(sandboxDir, to)),
       'renaming $from to $to');
 }
 
 /// Schedules creating a symlink at path [symlink] that points to [target],
 /// both of which are assumed to be relative to [sandboxDir].
 void scheduleSymlink(String target, String symlink) {
   schedule(
       () => createSymlink(
-          path.join(sandboxDir, target),
-          path.join(sandboxDir, symlink)),
+          p.join(sandboxDir, target),
+          p.join(sandboxDir, symlink)),
       'symlinking $target to $symlink');
 }
 
 /// Schedules a call to the Pub command-line utility.
 ///
 /// Runs Pub with [args] and validates that its results match [output] (or
 /// [outputJson]), [error], and [exitCode].
 ///
 /// [output] and [error] can be [String]s, [RegExp]s, or [Matcher]s.
 ///
@@ skipping 69 matching lines @@
 ///
 /// If a test suite runs pub more than once, we only need to run the compiler
 /// the first time.
 // TODO(rnystrom): Remove this when #104 is fixed.
 bool _compiledAsync = false;
 
 /// Gets the path to the pub entrypoint Dart script to run.
 // TODO(rnystrom): This exists to run the async/await compiler on pub and then
 // get the path to the output of that. Once #104 is fixed, remove this.
 String _getPubPath(String dartBin) {
-  var buildDir = path.join(path.dirname(dartBin), '../../');
+  var buildDir = p.join(p.dirname(dartBin), '../../');
 
   // Ensure the async/await compiler has been run once for this test suite. The
   // compiler itself will only re-compile source files that have actually
   // changed, so this is a no-op if everything is already compiled.
   if (!_compiledAsync) {
     var result = Process.runSync(dartBin, [
       '--package-root=$_packageRoot/',
-      path.join(testDirectory, '..', 'bin', 'async_compile.dart'),
+      p.join(testDirectory, '..', 'bin', 'async_compile.dart'),
       buildDir,
       '--silent'
     ]);
     stdout.write(result.stdout);
     stderr.write(result.stderr);
     if (result.exitCode != 0) fail("Async/await compiler failed.");
 
     _compiledAsync = true;
   }
 
-  return path.join(buildDir, 'pub_async/bin/pub.dart');
+  return p.join(buildDir, 'pub_async/bin/pub.dart');
 }
 
 /// Starts a Pub process and returns a [ScheduledProcess] that supports
 /// interaction with that process.
 ///
 /// Any futures in [args] will be resolved before the process is started.
 ScheduledProcess startPub({List args, Future<Uri> tokenEndpoint}) {
   String pathInSandbox(String relPath) {
-    return path.join(path.absolute(sandboxDir), relPath);
+    return p.join(p.absolute(sandboxDir), relPath);
   }
 
   ensureDir(pathInSandbox(appPath));
 
   // Find a Dart executable we can use to spawn. Use the same one that was
   // used to run this script itself.
   var dartBin = Platform.executable;
 
   // If the executable looks like a path, get its full path. That way we
   // can still find it when we spawn it with a different working directory.
   if (dartBin.contains(Platform.pathSeparator)) {
-    dartBin = path.absolute(dartBin);
+    dartBin = p.absolute(dartBin);
   }
 
   // Find the main pub entrypoint.
   var pubPath = _getPubPath(dartBin);
   // TODO(rnystrom): Replace the above line with the following when #104 is
   // fixed.
-  //var pubPath = path.join(testDirectory, '..', 'bin', 'pub.dart');
+  //var pubPath = p.join(testDirectory, '..', 'bin', 'pub.dart');
 
   var dartArgs = ['--package-root=$_packageRoot/', '--checked', pubPath,
       '--verbose'];
   dartArgs.addAll(args);
 
   if (tokenEndpoint == null) tokenEndpoint = new Future.value();
   var environmentFuture = tokenEndpoint.then((tokenEndpoint) {
     var environment = {};
     environment['_PUB_TESTING'] = 'true';
     environment['PUB_CACHE'] = pathInSandbox(cachePath);
@@ skipping 99 matching lines @@
       });
     }
 
     var pair = tee(_stderr);
     _stderr = pair.first;
     return pair.last;
   }
 }
 
 /// The path to the `packages` directory from which pub loads its dependencies.
-String get _packageRoot => path.absolute(Platform.packageRoot);
+String get _packageRoot => p.absolute(Platform.packageRoot);
 
 /// Fails the current test if Git is not installed.
 ///
 /// We require machines running these tests to have git installed. This
 /// validation gives an easier-to-understand error when that requirement isn't
 /// met than just failing in the middle of a test when pub invokes git.
 ///
 /// This also increases the [Schedule] timeout to 30 seconds on Windows,
 /// where Git runs really slowly.
 void ensureGit() {
@@ skipping 52 matching lines @@
 /// [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'),
+  d.file(p.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.
 ///
@@ skipping 16 matching lines @@
       var packagePath;
       if (package == 'barback' && _packageOverrides == null) {
         throw new StateError("createLockFile() can only create a lock file "
             "with a barback dependency within a withBarbackVersions() "
             "block.");
       }
 
       if (_packageOverrides.containsKey(package)) {
         packagePath = _packageOverrides[package];
       } else {
-        packagePath = path.join(pkgPath, package);
+        packagePath = p.join(pkgPath, package);
       }
 
       dependencies[package] = packagePath;
       var pubspec = loadYaml(
-          readTextFile(path.join(packagePath, 'pubspec.yaml')));
+          readTextFile(p.join(packagePath, 'pubspec.yaml')));
       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)
+      'relative': p.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;
     });
   }
@@ skipping 149 matching lines @@
 /// A function that creates a [Validator] subclass.
 typedef Validator ValidatorCreator(Entrypoint entrypoint);
 
 /// Schedules a single [Validator] to run on the [appPath].
 ///
 /// Returns a scheduled Future that contains the errors and warnings produced
 /// by that validator.
 Future<Pair<List<String>, List<String>>> schedulePackageValidation(
     ValidatorCreator fn) {
   return schedule(() {
-    var cache = new SystemCache.withSources(path.join(sandboxDir, cachePath));
+    var cache = new SystemCache.withSources(p.join(sandboxDir, cachePath));
 
     return syncFuture(() {
-      var validator = fn(new Entrypoint(path.join(sandboxDir, appPath), cache));
+      var validator = fn(new Entrypoint(p.join(sandboxDir, appPath), cache));
       return validator.validate().then((_) {
         return new Pair(validator.errors, validator.warnings);
       });
     });
   }, "validating package");
 }
 
 /// A matcher that matches a Pair.
 Matcher pairOf(Matcher firstMatcher, Matcher lastMatcher) =>
    new _PairMatcher(firstMatcher, lastMatcher);
@@ skipping 10 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"));