Index: test/package_config_info_test.dart |
diff --git a/test/package_config_info_test.dart b/test/package_config_info_test.dart |
new file mode 100644 |
index 0000000000000000000000000000000000000000..5dcc417b496b77c6da705d1422c0d17666abb52f |
--- /dev/null |
+++ b/test/package_config_info_test.dart |
@@ -0,0 +1,249 @@ |
+// Copyright (c) 2016, 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. |
+ |
+import 'dart:io'; |
+ |
+import 'package:path/path.dart' as p; |
+import 'package:shelf/shelf.dart' as shelf; |
+import 'package:shelf/shelf_io.dart' as shelf_io; |
+import 'package:test/test.dart'; |
+ |
+import 'package:package_resolver/package_resolver.dart'; |
+ |
+void main() { |
+ var resolver; |
+ setUp(() { |
+ resolver = new SyncPackageResolver.config({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar") |
+ }, uri: "file:///myapp/.packages"); |
+ }); |
+ |
+ group("constructor", () { |
+ test("with a URI object", () { |
+ var resolver = new SyncPackageResolver.config({}, |
+ uri: Uri.parse("file:///myapp/.packages")); |
+ expect(resolver.packageConfigUri, |
+ equals(Uri.parse("file:///myapp/.packages"))); |
+ }); |
+ |
+ test("with an invalid URI type", () { |
+ expect(() => new SyncPackageResolver.config({}, uri: 12), |
+ throwsArgumentError); |
+ }); |
+ }); |
+ |
+ test("exposes the config map", () { |
+ expect(resolver.packageConfigMap, equals({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar/") |
+ })); |
+ }); |
+ |
+ test("exposes the config URI if passed", () { |
+ expect(resolver.packageConfigUri, |
+ equals(Uri.parse("file:///myapp/.packages"))); |
+ }); |
+ |
+ test("exposes a data: config URI if none is passed", () { |
+ resolver = new SyncPackageResolver.config(resolver.packageConfigMap); |
+ expect(resolver.packageConfigUri, equals(Uri.parse( |
+ "data:;charset=utf-8," |
+ "foo:file:///foo/bar/%0A" |
+ "bar:http://dartlang.org/bar/%0A"))); |
+ }); |
+ |
+ test("exposes a null root", () { |
+ expect(resolver.packageRoot, isNull); |
+ }); |
+ |
+ test("processArgument uses --packages", () { |
+ expect(resolver.processArgument, |
+ equals("--packages=file:///myapp/.packages")); |
+ }); |
+ |
+ group("resolveUri", () { |
+ test("with a matching package", () { |
+ expect(resolver.resolveUri("package:foo/bang/qux.dart"), |
+ equals(Uri.parse("file:///foo/bar/bang/qux.dart"))); |
+ expect(resolver.resolveUri("package:bar/bang/qux.dart"), |
+ equals(Uri.parse("http://dartlang.org/bar/bang/qux.dart"))); |
+ }); |
+ |
+ test("with a matching package with no path", () { |
+ expect(resolver.resolveUri("package:foo"), isNull); |
+ }); |
+ |
+ test("with a matching package with an empty path", () { |
+ expect(resolver.resolveUri("package:bar/"), |
+ equals(Uri.parse("http://dartlang.org/bar/"))); |
+ }); |
+ |
+ test("with a URI object", () { |
+ expect(resolver.resolveUri(Uri.parse("package:foo/bang/qux.dart")), |
+ equals(Uri.parse("file:///foo/bar/bang/qux.dart"))); |
+ }); |
+ |
+ test("with a non-matching package", () { |
+ expect(resolver.resolveUri("package:zap/bang/qux.dart"), isNull); |
+ }); |
+ |
+ test("with an invalid argument type", () { |
+ expect(() => resolver.resolveUri(12), throwsArgumentError); |
+ }); |
+ |
+ test("with a non-package URI", () { |
+ expect(() => resolver.resolveUri("file:///zip/zap"), |
+ throwsFormatException); |
+ }); |
+ |
+ test("with an invalid package URI", () { |
+ expect(() => resolver.resolveUri("package:"), throwsFormatException); |
+ }); |
+ }); |
+ |
+ group("urlFor", () { |
+ test("with a matching package and no path", () { |
+ expect(resolver.urlFor("foo"), equals(Uri.parse("file:///foo/bar/"))); |
+ expect(resolver.urlFor("bar"), |
+ equals(Uri.parse("http://dartlang.org/bar/"))); |
+ }); |
+ |
+ test("with a matching package and a path", () { |
+ expect(resolver.urlFor("foo", "bang/qux.dart"), |
+ equals(Uri.parse("file:///foo/bar/bang/qux.dart"))); |
+ expect(resolver.urlFor("bar", "bang/qux.dart"), |
+ equals(Uri.parse("http://dartlang.org/bar/bang/qux.dart"))); |
+ }); |
+ |
+ test("with a non-matching package and no path", () { |
+ expect(resolver.urlFor("zap"), isNull); |
+ }); |
+ }); |
+ |
+ group("packageUriFor", () { |
+ test("converts matching URIs to package:", () { |
+ expect(resolver.packageUriFor("file:///foo/bar/bang/qux.dart"), |
+ equals(Uri.parse("package:foo/bang/qux.dart"))); |
+ expect(resolver.packageUriFor("http://dartlang.org/bar/bang/qux.dart"), |
+ equals(Uri.parse("package:bar/bang/qux.dart"))); |
+ }); |
+ |
+ test("converts URIs with no paths", () { |
+ expect(resolver.packageUriFor("file:///foo/bar"), |
+ equals(Uri.parse("package:foo/"))); |
+ expect(resolver.packageUriFor("http://dartlang.org/bar/"), |
+ equals(Uri.parse("package:bar/"))); |
+ }); |
+ |
+ test("with a URI object", () { |
+ expect(resolver.packageUriFor(Uri.parse("file:///foo/bar/bang/qux.dart")), |
+ equals(Uri.parse("package:foo/bang/qux.dart"))); |
+ }); |
+ |
+ test("with an invalid argument type", () { |
+ expect(() => resolver.packageUriFor(12), throwsArgumentError); |
+ }); |
+ }); |
+ |
+ group("packagePath", () { |
+ setUp(() { |
+ resolver = new SyncPackageResolver.config({ |
+ "foo": p.toUri(p.join(p.current, 'lib')), |
+ "bar": Uri.parse("http://dartlang.org/bar") |
+ }); |
+ }); |
+ |
+ test("with a matching package", () { |
+ expect(resolver.packagePath("foo"), equals(p.current)); |
+ }); |
+ |
+ test("with a package with a non-file scheme", () { |
+ expect(resolver.packagePath("bar"), isNull); |
+ }); |
+ |
+ test("with a non-matching", () { |
+ expect(resolver.packagePath("baz"), isNull); |
+ }); |
+ }); |
+ |
+ group("loadConfig", () { |
+ var server; |
+ var sandbox; |
+ setUp(() async { |
+ sandbox = (await Directory.systemTemp.createTemp("package_resolver_test")) |
+ .path; |
+ }); |
+ |
+ tearDown(() async { |
+ if (server != null) await server.close(); |
+ await new Directory(sandbox).delete(recursive: true); |
+ }); |
+ |
+ test("with an http: URI", () async { |
+ server = await shelf_io.serve((request) { |
+ return new shelf.Response.ok( |
+ "foo:file:///foo/bar/\n" |
+ "bar:http://dartlang.org/bar/"); |
+ }, 'localhost', 0); |
+ |
+ var resolver = await SyncPackageResolver.loadConfig( |
+ "http://localhost:${server.port}"); |
+ |
+ expect(resolver.packageConfigMap, equals({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar/") |
+ })); |
+ expect(resolver.packageConfigUri, |
+ equals(Uri.parse("http://localhost:${server.port}"))); |
+ }); |
+ |
+ test("with a file: URI", () async { |
+ var packagesPath = p.join(sandbox, ".packages"); |
+ new File(packagesPath).writeAsStringSync( |
+ "foo:file:///foo/bar/\n" |
+ "bar:http://dartlang.org/bar/"); |
+ |
+ var resolver = |
+ await SyncPackageResolver.loadConfig(p.toUri(packagesPath)); |
+ |
+ expect(resolver.packageConfigMap, equals({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar/") |
+ })); |
+ expect(resolver.packageConfigUri, equals(p.toUri(packagesPath))); |
+ }); |
+ |
+ test("with a data: URI", () async { |
+ var data = Uri.parse( |
+ "data:;charset=utf-8," |
+ "foo:file:///foo/bar/%0A" |
+ "bar:http://dartlang.org/bar/%0A"); |
+ var resolver = await SyncPackageResolver.loadConfig(data); |
+ |
+ expect(resolver.packageConfigMap, equals({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar/") |
+ })); |
+ expect(resolver.packageConfigUri, equals(data)); |
+ }); |
+ |
+ test("with a package: URI", () async { |
+ var resolver = await SyncPackageResolver.loadConfig( |
+ "package:package_resolver/src/test_package_config"); |
+ |
+ expect(resolver.packageConfigMap, equals({ |
+ "foo": Uri.parse("file:///foo/bar/"), |
+ "bar": Uri.parse("http://dartlang.org/bar/") |
+ })); |
+ expect(resolver.packageConfigUri, equals(Uri.parse( |
+ "package:package_resolver/src/test_package_config"))); |
+ }); |
+ |
+ test("with an unsupported scheme", () { |
+ expect(SyncPackageResolver.loadConfig("asdf:foo/bar"), |
+ throwsUnsupportedError); |
+ }); |
+ }); |
+} |