Gracefully handle pubspecs with dependencies using unknown sources.

sdk/lib/_internal/pub/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.
 
 library pub_update_test;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:unittest/unittest.dart';
@@ skipping 22 matching lines @@
 
   // Since this test isn't run from the SDK, it can't find the "version" file
   // to load. Instead, just manually inject a version.
   sdk.version = new Version(1, 2, 3);
 
   group('basic graph', basicGraph);
   group('with lockfile', withLockFile);
   group('root dependency', rootDependency);
   group('dev dependency', devDependency);
   group('unsolvable', unsolvable);
+  group('bad source', badSource);
   group('backtracking', backtracking);
   group('SDK constraint', sdkConstraint);
 }
 
 void basicGraph() {
   testResolve('no dependencies', {
     'myapp 0.0.0': {}
   }, result: {
     'myapp from root': '0.0.0'
   });
@@ skipping 344 matching lines @@
     },
     'b 1.0.0': {
       'a': '2.0.0'
     },
     'b 2.0.0': {
       'a': '1.0.0'
     }
   }, error: couldNotSolve, maxTries: 4);
 }
 
+badSource() {
+  testResolve('fail if the root package has a bad source in dep', {
+    'myapp 0.0.0': {
+      'foo from bad': 'any'
+    },
+  }, error: unknownSource('myapp', 'foo', 'bad'));
+
+  testResolve('fail if the root package has a bad source in dev dep', {
+    'myapp 0.0.0': {
+      '(dev) foo from bad': 'any'
+    },
+  }, error: unknownSource('myapp', 'foo', 'bad'));
+
+  testResolve('fail if all versions have bad source in dep', {
+    'myapp 0.0.0': {
+      'foo': 'any'
+    },
+    'foo 1.0.0': {
+      'bar from bad': 'any'
+    },
+    'foo 1.0.1': {
+      'baz from bad': 'any'
+    },
+    'foo 1.0.3': {
+      'bang from bad': 'any'
+    },
+  }, error: unknownSource('foo', 'bar', 'bad'), maxTries: 3);
+
+  testResolve('ignore versions with bad source in dep', {
+    'myapp 1.0.0': {
+      'foo': 'any'
+    },
+    'foo 1.0.0': {
+      'bar': 'any'
+    },
+    'foo 1.0.1': {
+      'bar from bad': 'any'
+    },
+    'foo 1.0.3': {
+      'bar from bad': 'any'
+    },
+    'bar 1.0.0': {}
+  }, result: {
+    'myapp from root': '1.0.0',
+    'foo': '1.0.0',
+    'bar': '1.0.0'
+  }, maxTries: 3);
+}
+
 backtracking() {
   testResolve('circular dependency on older version', {
     'myapp 0.0.0': {
       'a': '>=1.0.0'
     },
     'a 1.0.0': {},
     'a 2.0.0': {
       'b': '1.0.0'
     },
     'b 1.0.0': {
@@ skipping 351 matching lines @@
         var name = parts[0];
         var version = parts[1];
 
         var package = 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(name, package);
+          cache.sources[source].addPackage(name, package);
         }
       });
     });
 
     // Clean up the expectation.
     if (result != null) {
       var newResult = {};
       result.forEach((name, version) {
         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);
+            new PackageId(name, source1.name, version, name);
       });
     }
 
     // Make a version number like the continuous build's version.
     var previousVersion = sdk.version;
     if (useBleedingEdgeSdkVersion) {
       sdk.version = new Version(0, 1, 2, build: '0_r12345_juser');
     }
 
     // Resolve the versions.
@@ skipping 38 matching lines @@
 // happened during propagation. Since we don't specify the order that solutions
 // are tried, this just validates that *some* failure occurred, but not which.
 SolveFailMatcher couldNotSolve(maxTries) =>
     new SolveFailMatcher([], maxTries, null);
 
 FailMatcherBuilder sourceMismatch(String package1, String package2) {
   return (maxTries) => new SolveFailMatcher([package1, package2], maxTries,
       SourceMismatchException);
 }
 
+unknownSource(String depender, String dependency, String source) {
+  return (maxTries) => new SolveFailMatcher([depender, dependency, source],
+      maxTries, UnknownSourceException);
+}
+
 class SolveSuccessMatcher implements Matcher {
   /// The expected concrete package selections.
   final Map<String, PackageId> _expected;
 
   /// The maximum number of attempts that should have been tried before finding
   /// the solution.
   final int _maxTries;
 
   SolveSuccessMatcher(this._expected, this._maxTries);
 
   Description describe(Description description) {
     return description.add(
         'Solver to use at most $_maxTries attempts to find:\n'
         '${_listPackages(_expected.values)}');
   }
 
   Description describeMismatch(SolveResult result,
                                Description description,
                                MatchState state, bool verbose) {
     if (!result.succeeded) {
       description.add('Solver failed with:\n${result.error}');
-      return;
+      return null;
     }
 
     description.add('Resolved:\n${_listPackages(result.packages)}\n');
     description.add(state.state);
     return description;
   }
 
   bool matches(SolveResult result, MatchState state) {
     if (!result.succeeded) return false;
 
@@ skipping 135 matching lines @@
         throw new Exception('Version list for $description was already '
             'requested.');
       }
 
       _requestedVersions.add(description);
 
       if (!_packages.containsKey(description)){
         throw new Exception('MockSource does not have a package matching '
             '"$description".');
       }
+
       return _packages[description].keys.toList();
     });
   }
 
   Future<Pubspec> describe(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 45 matching lines @@
   });
 
   var name = description.replaceFirst(new RegExp(r"-[^-]+$"), "");
   var pubspec = new Pubspec(
       name, new Version.parse(version), dependencies, devDependencies,
       new PubspecEnvironment(sdkConstraint));
   return new Package.inMemory(pubspec);
 }
 
 void parseSource(String description,
-    callback(bool isDev, String name, Source source)) {
+    callback(bool isDev, String name, String 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
-  };
-
+  var source = "mock1";
   var match = new RegExp(r"(.*) from (.*)").firstMatch(description);
   if (match != null) {
     name = match[1];
-    source = sourceNames[match[2]];
+    source = match[2];
+    if (source == "root") source = null;
   }
 
   callback(isDev, name, source);
 }