Allow transformers in packages that are dev or override dependencies.

sdk/lib/_internal/pub/test/pubspec_test.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.
 
 library pubspec_test;
 
 import 'package:unittest/unittest.dart';
 
 import '../lib/src/pubspec.dart';
 import '../lib/src/source.dart';
@@ skipping 14 matching lines @@
 
 main() {
   initConfig();
   group('parse()', () {
     var sources = new SourceRegistry();
     sources.register(new MockSource());
 
     var throwsPubspecException =
       throwsA(new isInstanceOf<PubspecException>('PubspecException'));
 
-    expectPubspecException(String contents, fn(Pubspec pubspec)) {
+    expectPubspecException(String contents, fn(Pubspec pubspec),
+        [String expectedContains]) {
+      var expectation = throwsPubspecException;
+      if (expectedContains != null) {
+        expectation = throwsA(allOf(
+            new isInstanceOf<PubspecException>('PubspecException'),
+            predicate((error) => error.message.contains(expectedContains))));
+      }
+
       var pubspec = new Pubspec.parse(contents, sources);
-      expect(() => fn(pubspec), throwsPubspecException);
+      expect(() => fn(pubspec), expectation);
     }
 
     test("doesn't eagerly throw an error for an invalid field", () {
       // Shouldn't throw an error.
       new Pubspec.parse('version: not a semver', sources);
     });
 
     test("eagerly throws an error if the pubspec name doesn't match the "
         "expected name", () {
       expect(() => new Pubspec.parse("name: foo", sources, expectedName: 'bar'),
@@ skipping 160 matching lines @@
 
     test("throws if version is not a string", () {
       expectPubspecException('version: 1.0', (pubspec) => pubspec.version);
     });
 
     test("throws if version is not a version", () {
       expectPubspecException('version: not version',
           (pubspec) => pubspec.version);
     });
 
+    test("throws if transformers isn't a list", () {
+      expectPubspecException('transformers: "not list"',
+          (pubspec) => pubspec.transformers,
+          '"transformers" field must be a list');
+    });
+
     test("throws if a transformer isn't a string or map", () {
-      expectPubspecException('transformers: 12',
-          (pubspec) => pubspec.transformers);
       expectPubspecException('transformers: [12]',
-          (pubspec) => pubspec.transformers);
+          (pubspec) => pubspec.transformers,
+          '"transformers" field must be a string or map');
     });
 
     test("throws if a transformer's configuration isn't a map", () {
-      expectPubspecException('transformers: {pkg: 12}',
-          (pubspec) => pubspec.transformers);
+      expectPubspecException('transformers: [{pkg: 12}]',
+          (pubspec) => pubspec.transformers,
+          '"transformers.pkg" field must be a map');
     });
 
     test("throws if a transformer's configuration contains a top-level key "
         "beginning with a dollar sign", () {
-      expectPubspecException('transformers: {pkg: {\$key: value}}',
-          (pubspec) => pubspec.transformers);
+      expectPubspecException('''
+name: pkg
+transformers: [{pkg: {\$key: "value"}}]''',
+          (pubspec) => pubspec.transformers,
+          '"transformers.pkg" field cannot contain reserved field "\$key"');
     });
 
     test("doesn't throw if a transformer's configuration contains a "
         "non-top-level key beginning with a dollar sign", () {
-      expectPubspecException('transformers: {pkg: {\$key: value}}',
-          (pubspec) => pubspec.transformers);
+      var pubspec = new Pubspec.parse('''
+name: pkg
+transformers:
+- pkg: {outer: {\$inner: value}}
+''', sources);
+
+      var pkg = pubspec.transformers[0].single;
+      expect(pkg.configuration["outer"]["\$inner"], equals("value"));
+    });
+
+    test("throws if a transformer is not from a dependency", () {
+      expectPubspecException('''
+name: pkg
+transformers: [foo]
+''',
+          (pubspec) => pubspec.transformers,
+          '"transformers.foo" refers to a package that\'s not a dependency.');
+    });
+
+    test("allows a transformer from a normal dependency", () {
+      var pubspec = new Pubspec.parse('''
+name: pkg
+dependencies:
+  foo:
+    mock: ok
+transformers:
+- foo''', sources);
+
+      expect(pubspec.transformers[0].single.package, equals("foo"));
+    });
+
+    test("allows a transformer from a dev dependency", () {
+      var pubspec = new Pubspec.parse('''
+name: pkg
+dev_dependencies:
+  foo:
+    mock: ok
+transformers:
+- foo''', sources);
+
+      expect(pubspec.transformers[0].single.package, equals("foo"));
+    });
+
+    test("allows a transformer from a dependency override", () {
+      var pubspec = new Pubspec.parse('''
+name: pkg
+dependency_overrides:
+  foo:
+    mock: ok
+transformers:
+- foo''', sources);
+
+      expect(pubspec.transformers[0].single.package, equals("foo"));
     });
 
     test("allows comment-only files", () {
       var pubspec = new Pubspec.parse('''
 # No external dependencies yet
 # Including for completeness
 # ...and hoping the spec expands to include details about author, version, etc
 # See http://www.dartlang.org/docs/pub-package-manager/ for details
 ''', sources);
       expect(pubspec.version, equals(Version.none));
@@ skipping 34 matching lines @@
             (pubspec) => pubspec.environment);
       });
 
       test("throws if the sdk isn't a valid version constraint", () {
         expectPubspecException('environment: {sdk: "oopies"}',
             (pubspec) => pubspec.environment);
       });
     });
   });
 }