Add support to the version solver for sources that only have a single version per package.

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:io');
 #import('dart:isolate');
 
 #import('../../pub/package.dart');
 #import('../../pub/pubspec.dart');
 #import('../../pub/source.dart');
 #import('../../pub/source_registry.dart');
 #import('../../pub/utils.dart');
 #import('../../pub/version.dart');
 #import('../../pub/version_solver.dart');
 #import('../../../lib/unittest/unittest.dart');
 
 final noVersion = 'no version';
 final disjointConstraint = 'disjoint';
 final sourceMismatch = 'source mismatch';
 final descriptionMismatch = 'description mismatch';
 final couldNotSolve = 'unsolved';
 
 Source source1;
 Source source2;
+Source versionlessSource;
 
 main() {
   testResolve('no dependencies', {
     'myapp 0.0.0': {}
   }, result: {
     'myapp': '0.0.0'
   });
 
   testResolve('simple dependency tree', {
     'myapp 0.0.0': {
@@ skipping 59 matching lines @@
     'bang 1.0.0': {},
     'whoop 1.0.0': {},
     'zoop 1.0.0': {}
   }, result: {
     'myapp': '0.0.0',
     'foo': '1.0.1',
     'bar': '1.0.0',
     'bang': '1.0.0'
   });
 
+  testResolve('from versionless source', {
+    'myapp 0.0.0': {
+      'foo from versionless': 'any'
+    },
+    'foo 1.2.3 from versionless': {}
+  }, result: {
+    'myapp': '0.0.0',
+    'foo': '1.2.3'
+  });
+
+  testResolve('transitively through versionless source', {
+    'myapp 0.0.0': {
+      'foo from versionless': 'any'
+    },
+    'foo 1.2.3 from versionless': { 'bar': '>=1.0.0' },

[Bob Nystrom, 2012/07/11 16:55:13]

Can you split this map onto the next line like the other tests?

[nweiz, 2012/07/11 19:11:37]

Done.

+    'bar 1.1.0': {}
+  }, result: {
+    'myapp': '0.0.0',
+    'foo': '1.2.3',
+    'bar': '1.1.0'
+  });
+
   testResolve('dependency back onto root package', {
     'myapp 1.0.0': {
       'foo': '1.0.0'
     },
     'foo 1.0.0': {
       'myapp': '>=1.0.0'
     }
   }, error: sourceMismatch);
 
   testResolve('no version that matches requirement', {
@@ skipping 83 matching lines @@
 // - 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, [result, error]) {
   test(description, () {
     var sources = new SourceRegistry();
     source1 = new MockSource('mock1');
     source2 = new MockSource('mock2');
+    versionlessSource = new MockVersionlessSource();
     sources.register(source1);
     sources.register(source2);
+    sources.register(versionlessSource);
     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 parts = nameVersion.split(' ');
       var name = parts[0];
       var version = parts[1];
 
-      var package = source.mockPackage(name, version, dependencies);
+      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);
       }
     });
 
@@ skipping 75 matching lines @@
           parsed.last, new VersionConstraint.parse(constraint), parsed.first));
     });
 
     var pubspec = new Pubspec(new Version.parse(version), dependencies);
     return new Package.inMemory(description, pubspec);
   }
 
   void addPackage(Package package) {
     _packages.putIfAbsent(package.name, () => new Map<Version, Package>());
     _packages[package.name][package.version] = package;
-    return package;
   }
 
   String packageName(String description) =>
     description.replaceFirst(new RegExp(@"-[^-]+$"), "");
 }
 
+/**
+ * A source used for testing that doesn't natively understand versioning,
+ * similar to how the Git and SDK sources work.
+ */
+class MockVersionlessSource extends Source {
+  final Map<String, Package> _packages;
+
+  final String name = 'versionless';
+  final bool shouldCache = false;
+
+  MockVersionlessSource()
+    : _packages = <Package>{};
+
+  Future<bool> install(PackageId id, String path) {
+    throw 'no';
+  }
+
+  Future<Pubspec> describe(PackageId id) {
+    return new Future<Pubspec>.immediate(_packages[id.description].pubspec);
+  }
+
+  void addPackage(Package package) {
+    _packages[package.name] = package;
+  }
+}
+
 Future fakeAsync(callback()) {
   var completer = new Completer();
   new Timer(0, (_) {
     completer.complete(callback());
   });
 
   return completer.future;
 }
 
 Pair<String, Source> parseSource(String name) {
   var match = new RegExp(@"(.*) 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 'versionless':
+    return new Pair<String, Source>(match[1], versionlessSource);
   }
 }