Roll Observatory packages and add a roll script

packages/package_config/test/discovery_analysis_test.dart

Index: packages/package_config/test/discovery_analysis_test.dart
diff --git a/packages/package_config/test/discovery_analysis_test.dart b/packages/package_config/test/discovery_analysis_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f33a4a8c61030becf228e7e5bd9dcae05b4653c7
--- /dev/null
+++ b/packages/package_config/test/discovery_analysis_test.dart
@@ -0,0 +1,124 @@
+// Copyright (c) 2015, 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.
+
+library package_config.discovery_analysis_test;
+
+import "dart:async";
+import "dart:io";
+
+import "package:package_config/discovery_analysis.dart";
+import "package:package_config/packages.dart";
+import "package:path/path.dart" as path;
+import "package:test/test.dart";
+
+main() {
+  fileTest("basic",
+           {".packages": packagesFile,
+            "foo": {".packages": packagesFile},
+            "bar": {"packages": {"foo": {}, "bar":{}, "baz": {}}},
+            "baz": {}},
+           (Directory directory) {
+    var dirUri = new Uri.directory(directory.path);
+    PackageContext ctx = PackageContext.findAll(directory);
+    PackageContext root = ctx[directory];
+    expect(root, same(ctx));
+    validatePackagesFile(root.packages, dirUri);
+    var fooDir = sub(directory, "foo");
+    PackageContext foo = ctx[fooDir];
+    expect(identical(root, foo), isFalse);
+    validatePackagesFile(foo.packages, dirUri.resolve("foo/"));
+    var barDir = sub(directory, "bar");
+    PackageContext bar = ctx[sub(directory, "bar")];
+    validatePackagesDir(bar.packages, dirUri.resolve("bar/"));
+    PackageContext barbar = ctx[sub(barDir, "bar")];
+    expect(barbar, same(bar));  // inherited.
+    PackageContext baz = ctx[sub(directory, "baz")];
+    expect(baz, same(root));  // inherited.
+
+    var map = ctx.asMap();
+    expect(map.keys.map((dir) => dir.path),
+           unorderedEquals([directory.path, fooDir.path, barDir.path]));
+  });
+}
+
+Directory sub(Directory parent, String dirName) {
+  return new Directory(path.join(parent.path, dirName));
+}
+
+const packagesFile = """
+# A comment
+foo:file:///dart/packages/foo/
+bar:http://example.com/dart/packages/bar/
+baz:packages/baz/
+""";
+
+void validatePackagesFile(Packages resolver, Uri location) {
+  expect(resolver, isNotNull);
+  expect(resolver.resolve(pkg("foo", "bar/baz")),
+         equals(Uri.parse("file:///dart/packages/foo/bar/baz")));
+  expect(resolver.resolve(pkg("bar", "baz/qux")),
+         equals(Uri.parse("http://example.com/dart/packages/bar/baz/qux")));
+  expect(resolver.resolve(pkg("baz", "qux/foo")),
+         equals(location.resolve("packages/baz/qux/foo")));
+  expect(resolver.packages, unorderedEquals(["foo", "bar", "baz"]));
+}
+
+void validatePackagesDir(Packages resolver, Uri location) {
+  // Expect three packages: foo, bar and baz
+  expect(resolver, isNotNull);
+  expect(resolver.resolve(pkg("foo", "bar/baz")),
+         equals(location.resolve("packages/foo/bar/baz")));
+  expect(resolver.resolve(pkg("bar", "baz/qux")),
+         equals(location.resolve("packages/bar/baz/qux")));
+  expect(resolver.resolve(pkg("baz", "qux/foo")),
+         equals(location.resolve("packages/baz/qux/foo")));
+  if (location.scheme == "file") {
+    expect(resolver.packages, unorderedEquals(["foo", "bar", "baz"]));
+  } else {
+    expect(() => resolver.packages, throws);
+  }
+}
+
+Uri pkg(String packageName, String packagePath) {
+  var path;
+  if (packagePath.startsWith('/')) {
+    path = "$packageName$packagePath";
+  } else {
+    path = "$packageName/$packagePath";
+  }
+  return new Uri(scheme: "package", path: path);
+}
+
+/// Create a directory structure from [description] and run [fileTest].
+///
+/// Description is a map, each key is a file entry. If the value is a map,
+/// it's a sub-dir, otherwise it's a file and the value is the content
+/// as a string.
+void fileTest(String name,
+              Map description,
+              Future fileTest(Directory directory)) {
+  group("file-test", () {
+    Directory tempDir = Directory.systemTemp.createTempSync("file-test");
+    setUp(() {
+      _createFiles(tempDir, description);
+    });
+    tearDown(() {
+      tempDir.deleteSync(recursive: true);
+    });
+    test(name, () => fileTest(tempDir));
+  });
+}
+
+void _createFiles(Directory target, Map description) {
+  description.forEach((name, content) {
+    if (content is Map) {
+      Directory subDir = new Directory(path.join(target.path, name));
+      subDir.createSync();
+      _createFiles(subDir, content);
+    } else {
+      File file = new File(path.join(target.path, name));
+      file.writeAsStringSync(content, flush: true);
+    }
+  });
+}