Track Source objects in PackageNames.

test/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.
 
 import 'dart:async';
 
 import 'package:pub/src/lock_file.dart';
 import 'package:pub/src/log.dart' as log;
 import 'package:pub/src/package.dart';
 import 'package:pub/src/pubspec.dart';
 import 'package:pub/src/sdk.dart' as sdk;
 import 'package:pub/src/solver/version_solver.dart';
 import 'package:pub/src/source.dart';
 import 'package:pub/src/source/cached.dart';
+import 'package:pub/src/source_registry.dart';
 import 'package:pub/src/system_cache.dart';
 import 'package:pub/src/utils.dart';
 import 'package:pub_semver/pub_semver.dart';
 import 'package:test/test.dart';
 
 MockSource source1;
 MockSource source2;
 
 main() {
   // Uncomment this to debug failing tests.
@@ skipping 620 matching lines @@
     'b 2.0.0': {
       'a-y': 'any'
     },
     'c 1.0.0': {},
     'c 2.0.0': {},
     'c 3.0.0': {},
     'c 4.0.0': {},
     'c 5.0.0': {},
   }, result: {
     'myapp from root': '0.0.0',
-    'a': '1.0.0',
+    'a-x': '1.0.0',

[Bob Nystrom, 2016/06/23 20:29:49]

Why the change here?

[nweiz, 2016/06/23 21:01:21]

Previously, the result wasn't validating which "a 1.0.0" was selected; it could
have been the one with description "x" or the one with description "y". They
were ==-identical so the test didn't care.

Now that == cares about descriptions, we need to be explicit about which one is
selected. It also makes the test more accurate too.

[Bob Nystrom, 2016/06/23 22:02:20]

Ah, cool. I thought it was actually producing a different result.

     'b': '1.0.0',
     'c': '5.0.0'
   }, maxTries: 2);
 
   // Similar to the above two tests but where there is no solution. It should
   // fail in this case with no backtracking.
   testResolve('backjump to conflicting source', {
     'myapp 0.0.0': {
       'a': 'any',
       'b': 'any',
@@ skipping 448 matching lines @@
     source2 = new MockSource('mock2');
 
     var cache = new SystemCache(rootDir: '.');
     cache.sources.register(source1);
     cache.sources.register(source2);
     cache.sources.setDefault(source1.name);
 
     // Build the test package graph.
     var root;
     packages.forEach((description, dependencies) {
-      var id = parseSpec(description);
-      var package = mockPackage(id, dependencies,
+      var id = parseSpec(cache.sources, description);
+      var package = mockPackage(cache.sources, id, dependencies,
           id.name == 'myapp' ? overrides : null);
       if (id.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 {
         (cache.source(id.source) as BoundMockSource)
             .addPackage(id.description, package);
       }
     });
 
     // Clean up the expectation.
     if (result != null) {
       var newResult = {};
       result.forEach((description, version) {
-        var id = parseSpec(description, version);
+        var id = parseSpec(cache.sources, description, version);
         newResult[id.name] = id;
       });
       result = newResult;
     }
 
     // Parse the lockfile.
     var realLockFile;
     if (lockfile == null) {
-      realLockFile = new LockFile.empty(cache.sources);
+      realLockFile = new LockFile.empty();
     } else {
       realLockFile = new LockFile(lockfile.keys.map((name) {
         var version = new Version.parse(lockfile[name]);
-        return new PackageId(name, source1.name, version, name);
-      }), cache.sources);
+        return new PackageId(name, source1, version, name);
+      }));
     }
 
     // Resolve the versions.
     log.verbosity = log.Verbosity.NONE;
     var future = resolveVersions(
         downgrade ? SolveType.DOWNGRADE : SolveType.GET,
         cache, root, lockFile: realLockFile);
 
     var matcher;
     if (result != null) {
@@ skipping 184 matching lines @@
 /// characters.
 class MockSource extends Source {
   final String name;
   final hasMultipleVersions = true;
 
   MockSource(this.name);
 
   BoundSource bind(SystemCache cache) => new BoundMockSource(this, cache);
 
   PackageRef parseRef(String name, description, {String containingPath}) =>
-      new PackageRef(name, this.name, description);
+      new PackageRef(name, this, description);
 
   PackageId parseId(String name, Version version, description) =>
-      new PackageId(name, this.name, version, description);
+      new PackageId(name, this, version, description);
 
   bool descriptionsEqual(description1, description2) =>
       description1 == description2;
+
+  int hashDescription(description) => description.hashCode;
 }
 
 class BoundMockSource extends CachedSource {
   final SystemCache systemCache;
 
   final MockSource source;
 
   final _packages = <String, Map<Version, Package>>{};
 
   /// Keeps track of which package version lists have been requested. Ensures
@@ skipping 18 matching lines @@
     }
 
     _requestedVersions.add(ref.description);
 
     if (!_packages.containsKey(ref.description)){
       throw new Exception('MockSource does not have a package matching '
           '"${ref.description}".');
     }
 
     return _packages[ref.description].values.map((package) {
-      return new PackageId(
-          ref.name, source.name, package.version, ref.description);
+      return new PackageId(ref.name, source, package.version, ref.description);
     }).toList();
   }
 
   Future<Pubspec> describeUncached(PackageId id) {
     return new Future.sync(() {
       // Make sure the solver doesn't request the same thing twice.
       if (_requestedPubspecs.containsKey(id.description) &&
           _requestedPubspecs[id.description].contains(id.version)) {
         throw new Exception('Pubspec for $id was already requested.');
       }
@@ skipping 13 matching lines @@
 
   Future<Pair<List<PackageId>, List<PackageId>>> repairCachedPackages() =>
       throw new UnsupportedError('Cannot repair mock packages');
 
   void addPackage(String description, Package package) {
     _packages.putIfAbsent(description, () => new Map<Version, Package>());
     _packages[description][package.version] = package;
   }
 }
 
-Package mockPackage(PackageId id, Map dependencyStrings, Map overrides) {
+Package mockPackage(SourceRegistry sources, PackageId id, Map dependencyStrings,
+    Map overrides) {
   var sdkConstraint = null;
 
   // Build the pubspec dependencies.
   var dependencies = <PackageDep>[];
   var devDependencies = <PackageDep>[];
 
   dependencyStrings.forEach((spec, constraint) {
     var isDev = spec.startsWith("(dev) ");
     if (isDev) {
       spec = spec.substring("(dev) ".length);
     }
 
-    var dep = parseSpec(spec).withConstraint(
+    var dep = parseSpec(sources, spec).withConstraint(
         new VersionConstraint.parse(constraint));
 
     if (dep.name == 'sdk') {
       sdkConstraint = dep.constraint;
       return;
     }
 
     if (isDev) {
       devDependencies.add(dep);
     } else {
       dependencies.add(dep);
     }
   });
 
   var dependencyOverrides = <PackageDep>[];
   if (overrides != null) {
     overrides.forEach((spec, constraint) {
-      dependencyOverrides.add(parseSpec(spec).withConstraint(
-          new VersionConstraint.parse(constraint)));
+      dependencyOverrides.add(parseSpec(sources, spec)
+          .withConstraint(new VersionConstraint.parse(constraint)));
     });
   }
 
   return new Package.inMemory(new Pubspec(id.name,
       version: id.version,
       dependencies: dependencies,
       devDependencies: devDependencies,
       dependencyOverrides: dependencyOverrides,
       sdkConstraint: sdkConstraint));
 }
 
 /// Creates a new [PackageId] parsed from [text], which looks something like
 /// this:
 ///
 ///   foo-xyz 1.0.0 from mock
 ///
 /// The package name is "foo". A hyphenated suffix like "-xyz" here is part
 /// of the package description, but not its name, so the description here is
 /// "foo-xyz".
 ///
 /// This is followed by an optional [Version]. If [version] is provided, then
 /// it is parsed to a [Version], and [text] should *not* also contain a
 /// version string.
 ///
 /// The "from mock" optional suffix is the name of a source for the package.
 /// If omitted, it defaults to "mock1".
-PackageId parseSpec(String text, [String version]) {
+PackageId parseSpec(SourceRegistry sources, String text, [String version]) {
   var pattern = new RegExp(r"(([a-z_]*)(-[a-z_]+)?)( ([^ ]+))?( from (.*))?$");
   var match = pattern.firstMatch(text);
   if (match == null) {
     throw new FormatException("Could not parse spec '$text'.");
   }
 
   var description = match[1];
   var name = match[2];
 
   var parsedVersion;
   if (version != null) {
     // Spec string shouldn't also contain a version.
     if (match[5] != null) {
       throw new ArgumentError("Spec '$text' should not contain a version "
           "since '$version' was passed in explicitly.");
     }
     parsedVersion = new Version.parse(version);
   } else {
     if (match[5] != null) {
       parsedVersion = new Version.parse(match[5]);
     } else {
       parsedVersion = Version.none;
     }
   }
 
-  var source = "mock1";
-  if (match[7] != null) {
-    source = match[7];
-    if (source == "root") source = null;
-  }
+  var source = sources["mock1"];
+  if (match[7] != null) source = match[7] == "root" ? null : sources[match[7]];
 
   return new PackageId(name, source, parsedVersion, description);
 }