Dev dependencies.

utils/tests/pub/version_solver_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 pub_update_test;
 
 import 'dart:async';
 import 'dart:io';
 
+import '../../../pkg/unittest/lib/unittest.dart';
+
 import '../../pub/lock_file.dart';
 import '../../pub/package.dart';
 import '../../pub/pubspec.dart';
 import '../../pub/source.dart';
 import '../../pub/source_registry.dart';
 import '../../pub/system_cache.dart';
 import '../../pub/utils.dart';
 import '../../pub/version.dart';
 import '../../pub/version_solver.dart';
-import '../../../pkg/unittest/lib/unittest.dart';
+import 'test_pub.dart';
 
 Matcher noVersion(List<String> packages) {
   return predicate((x) {
     if (x is! NoVersionException) return false;
 
     // Make sure the error string mentions the conflicting dependers.
     var message = x.toString();
     return packages.every((package) => message.contains(package));
   }, "is a NoVersionException");
 }
@@ skipping 33 matching lines @@
 
     return true;
   }, "is a SourceMismatchException");
 }
 
 MockSource source1;
 MockSource source2;
 Source versionlessSource;
 
 main() {
+  initConfig();
+
   testResolve('no dependencies', {
     'myapp 0.0.0': {}
   }, result: {
     'myapp from root': '0.0.0'
   });
 
   testResolve('simple dependency tree', {
     'myapp 0.0.0': {
       'a': '1.0.0',
       'b': '1.0.0'
@@ skipping 279 matching lines @@
     },
     'a 1.0.0': {},
     'a 2.0.0': {
       'b': '1.0.0'
     },
     'b 1.0.0': {
       'a': '1.0.0'
     }
   }, error: couldNotSolve);
 
+  group('dev dependencies', () {
+    testResolve("includes root package's dev dependencies", {
+      'myapp 1.0.0': {
+        '(dev) foo': '1.0.0',
+        '(dev) bar': '1.0.0'
+      },
+      'foo 1.0.0': {},
+      'bar 1.0.0': {}
+    }, result: {
+      'myapp from root': '1.0.0',
+      'foo': '1.0.0',
+      'bar': '1.0.0'
+    });
+
+    testResolve("includes dev dependency's transitive dependencies", {
+      'myapp 1.0.0': {
+        '(dev) foo': '1.0.0'
+      },
+      'foo 1.0.0': {
+        'bar': '1.0.0'
+      },
+      'bar 1.0.0': {}
+    }, result: {
+      'myapp from root': '1.0.0',
+      'foo': '1.0.0',
+      'bar': '1.0.0'
+    });
+
+    testResolve("ignores transitive dependency's dev dependencies", {
+      'myapp 1.0.0': {
+        'foo': '1.0.0'
+      },
+      'foo 1.0.0': {
+        '(dev) bar': '1.0.0'
+      },
+      'bar 1.0.0': {}
+    }, result: {
+      'myapp from root': '1.0.0',
+      'foo': '1.0.0'
+    });
+  });
+}
+
 // TODO(rnystrom): More stuff to test:
 // - Depending on a non-existent package.
 // - Test that only a certain number requests are sent to the mock source so we
 //   can keep track of server traffic.
-}
 
 testResolve(description, packages, {lockfile, result, Matcher error}) {
   test(description, () {
     var cache = new SystemCache('.');
     source1 = new MockSource('mock1');
     source2 = new MockSource('mock2');
     versionlessSource = new MockVersionlessSource();
     cache.register(source1);
     cache.register(source2);
     cache.register(versionlessSource);
     cache.sources.setDefault(source1.name);
 
     // Build the test package graph.
     var root;
     packages.forEach((nameVersion, dependencies) {
-      var parsed = parseSource(nameVersion);
-      nameVersion = parsed.first;
-      var source = parsed.last;
+      var parsed = parseSource(nameVersion, (isDev, nameVersion, source) {
+        var parts = nameVersion.split(' ');
+        var name = parts[0];
+        var version = parts[1];
 
-      var parts = nameVersion.split(' ');
-      var name = parts[0];
-      var version = parts[1];
-
-      var package = source1.mockPackage(name, version, dependencies);
-      if (name == 'myapp') {
-        // Don't add the root package to the server, so we can verify that Pub
-        // doesn't try to look up information about the local package on the
-        // remote server.
-        root = package;
-      } else {
-        source.addPackage(package);
-      }
+        var package = source1.mockPackage(name, version, dependencies);
+        if (name == 'myapp') {
+          // Don't add the root package to the server, so we can verify that Pub
+          // doesn't try to look up information about the local package on the
+          // remote server.
+          root = package;
+        } else {
+          source.addPackage(package);
+        }
+      });
     });
 
     // Clean up the expectation.
     if (result != null) {
       var newResult = {};
       result.forEach((name, version) {
-        var parsed = parseSource(name);
-        name = parsed.first;
-        var source = parsed.last;
-        version = new Version.parse(version);
-        newResult[name] = new PackageId(name, source, version, name);
+        parseSource(name, (isDev, name, source) {
+          version = new Version.parse(version);
+          newResult[name] = new PackageId(name, source, version, name);
+        });
       });
       result = newResult;
     }
 
     var realLockFile = new LockFile.empty();
     if (lockfile != null) {
       lockfile.forEach((name, version) {
         version = new Version.parse(version);
         realLockFile.packages[name] =
           new PackageId(name, source1, version, name);
@@ skipping 45 matching lines @@
   }
 
   Future<bool> install(PackageId id, String path) {
     throw 'no';
   }
 
   Package mockPackage(String description, String version,
       Map dependencyStrings) {
     // Build the pubspec dependencies.
     var dependencies = <PackageRef>[];
+    var devDependencies = <PackageRef>[];
+
     dependencyStrings.forEach((name, constraint) {
-      var parsed = parseSource(name);
-      var description = parsed.first;
-      var packageName = description.replaceFirst(new RegExp(r"-[^-]+$"), "");
-      dependencies.add(new PackageRef(packageName, parsed.last,
-          new VersionConstraint.parse(constraint), description));
+      parseSource(name, (isDev, name, source) {
+        var packageName = name.replaceFirst(new RegExp(r"-[^-]+$"), "");
+        var ref = new PackageRef(packageName, source,
+            new VersionConstraint.parse(constraint), name);
+
+        if (isDev) {
+          devDependencies.add(ref);
+        } else {
+          dependencies.add(ref);
+        }
+      });
     });
 
     var pubspec = new Pubspec(
-        description, new Version.parse(version), dependencies,
+        description, new Version.parse(version), dependencies, devDependencies,
         new PubspecEnvironment());
     return new Package.inMemory(pubspec);
   }
 
   void addPackage(Package package) {
     _packages.putIfAbsent(package.name, () => new Map<Version, Package>());
     _packages[package.name][package.version] = package;
   }
 }
 
@@ skipping 14 matching lines @@
 
   Future<Pubspec> describe(PackageId id) {
     return new Future<Pubspec>.immediate(_packages[id.description].pubspec);
   }
 
   void addPackage(Package package) {
     _packages[package.name] = package;
   }
 }
 
-Pair<String, Source> parseSource(String name) {
-  var match = new RegExp(r"(.*) from (.*)").firstMatch(name);
-  if (match == null) return new Pair<String, Source>(name, source1);
-  switch (match[2]) {
-  case 'mock1': return new Pair<String, Source>(match[1], source1);
-  case 'mock2': return new Pair<String, Source>(match[1], source2);
-  case 'root': return new Pair<String, Source>(match[1], null);
-  case 'versionless':
-    return new Pair<String, Source>(match[1], versionlessSource);
+void parseSource(String description,
+    callback(bool isDev, String name, Source source)) {
+  var isDev = false;
+
+  if (description.startsWith("(dev) ")) {
+    description = description.substring("(dev) ".length);
+    isDev = true;
   }
+
+  var name = description;
+  var source = source1;
+
+  var sourceNames = {
+    'mock1': source1,
+    'mock2': source2,
+    'root': null,
+    'versionless': versionlessSource
+  };
+
+  var match = new RegExp(r"(.*) from (.*)").firstMatch(description);
+  if (match != null) {
+    name = match[1];
+    source = sourceNames[match[2]];
+  }
+
+  callback(isDev, name, source);
 }