Better error messages for dependency conflicts.

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/lock_file.dart';
 import '../../pub/package.dart';
 import '../../pub/pubspec.dart';
 import '../../pub/root_source.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';
 
-final noVersion = 'no version';
-final disjointConstraint = 'disjoint';
-final sourceMismatch = 'source mismatch';
-final descriptionMismatch = 'description mismatch';
-final couldNotSolve = 'unsolved';
+Matcher noVersion(List<String> packages) {

[nweiz, 2012/12/06 00:58:55]

I think the unittest style would have this be "isNoVersion" or
"isNoVersionException".

+  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");
+}
+
+Matcher disjointConstraint(List<String> packages) {
+  return predicate((x) {
+    if (x is! DisjointConstraintException) return false;
+
+    // Make sure the error string mentions the conflicting dependers.
+    var message = x.toString();
+    return packages.every((package) => message.contains(package));
+  }, "is a DisjointConstraintException");
+}
+
+Matcher descriptionMismatch(String package1, String package2) {
+  return predicate((x) {
+    if (x is! DescriptionMismatchException) return false;
+
+    // Make sure the error string mentions the conflicting dependers.
+    if (!x.toString().contains(package1)) return false;
+    if (!x.toString().contains(package2)) return false;
+
+    return true;
+  }, "is a DescriptionMismatchException");
+}
+
+final couldNotSolve = predicate((x) => x is CouldNotSolveException,
+    "is a CouldNotSolveException");
+
+Matcher sourceMismatch(String package1, String package2) {
+  return predicate((x) {
+    if (x is! SourceMismatchException) return false;
+
+    // Make sure the error string mentions the conflicting dependers.
+    if (!x.toString().contains(package1)) return false;
+    if (!x.toString().contains(package2)) return false;
+
+    return true;
+  }, "is a SourceMismatchException");
+}
 
 MockSource source1;
 MockSource source2;
 Source versionlessSource;
 Source rootSource;
 
 main() {
   testResolve('no dependencies', {
     'myapp 0.0.0': {}
   }, result: {
@@ skipping 194 matching lines @@
     'myapp 1.0.0': {
       'foo': '1.0.0',
       'bar': '1.0.0'
     },
     'foo 1.0.0': {
       'myapp': '>=1.0.0'
     },
     'bar 1.0.0': {
       'myapp from mock2': '>=1.0.0'
     }
-  }, error: sourceMismatch);
+  }, error: sourceMismatch('foo', 'bar'));
 
   testResolve('dependency back onto root package with wrong version', {
     'myapp 1.0.0': {
       'foo': '1.0.0'
     },
     'foo 1.0.0': {
       'myapp': '<1.0.0'
     }
-  }, error: disjointConstraint);
+  }, error: disjointConstraint(['foo']));
 
   testResolve('no version that matches requirement', {
     'myapp 0.0.0': {
       'foo': '>=1.0.0 <2.0.0'
     },
     'foo 2.0.0': {},
     'foo 2.1.3': {}
-  }, error: noVersion);
+  }, error: noVersion(['myapp']));
 
   testResolve('no version that matches combined constraint', {
     'myapp 0.0.0': {
       'foo': '1.0.0',
       'bar': '1.0.0'
     },
     'foo 1.0.0': {
       'shared': '>=2.0.0 <3.0.0'
     },
     'bar 1.0.0': {
       'shared': '>=2.9.0 <4.0.0'
     },
     'shared 2.5.0': {},
     'shared 3.5.0': {}
-  }, error: noVersion);
+  }, error: noVersion(['foo', 'bar']));
 
   testResolve('disjoint constraints', {
     'myapp 0.0.0': {
       'foo': '1.0.0',
       'bar': '1.0.0'
     },
     'foo 1.0.0': {
       'shared': '<=2.0.0'
     },
     'bar 1.0.0': {
       'shared': '>3.0.0'
     },
     'shared 2.0.0': {},
     'shared 4.0.0': {}
-  }, error: disjointConstraint);
+  }, error: disjointConstraint(['foo', 'bar']));
 
   testResolve('mismatched descriptions', {
     'myapp 0.0.0': {
       'foo': '1.0.0',
       'bar': '1.0.0'
     },
     'foo 1.0.0': {
       'shared-x': '1.0.0'
     },
     'bar 1.0.0': {
       'shared-y': '1.0.0'
     },
     'shared-x 1.0.0': {},
     'shared-y 1.0.0': {}
-  }, error: descriptionMismatch);
+  }, error: descriptionMismatch('foo', 'bar'));
 
   testResolve('mismatched sources', {
     'myapp 0.0.0': {
       'foo': '1.0.0',
       'bar': '1.0.0'
     },
     'foo 1.0.0': {
       'shared': '1.0.0'
     },
     'bar 1.0.0': {
       'shared from mock2': '1.0.0'
     },
     'shared 1.0.0': {},
     'shared 1.0.0 from mock2': {}
-  }, error: sourceMismatch);
+  }, error: sourceMismatch('foo', 'bar'));
 
   testResolve('unstable dependency graph', {
     'myapp 0.0.0': {
       'a': '>=1.0.0'
     },
     'a 1.0.0': {},
     'a 2.0.0': {
       'b': '1.0.0'
     },
     'b 1.0.0': {
       'a': '1.0.0'
     }
   }, error: couldNotSolve);
 
 // TODO(rnystrom): More stuff to test:
-// - Two packages depend on the same package, but from different sources. Should
-//   fail.
 // - 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, error}) {
+testResolve(description, packages, {lockfile, result, Matcher error}) {
   test(description, () {
-    var isNoVersionException = predicate((x)=> x is NoVersionException,
-        "is a NoVersionException");
-    var isDisjointConstraintException =
-        predicate((x)=> x is DisjointConstraintException,
-       "    is a DisjointConstraintException");
-    var isSourceMismatchException =
-        predicate((x)=> x is SourceMismatchException,
-            "is a SourceMismatchException");
-    var isDescriptionMismatchException =
-        predicate((x)=> x is DescriptionMismatchException,
-            "is a DescriptionMismatchException");
-    var isCouldNotSolveException = predicate((x)=> x is CouldNotSolveException,
-            "is a CouldNotSolveException");
-
     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.
@@ skipping 47 matching lines @@
 
     if (result != null) {
       expect(future, completion(predicate((actualResult) {
         for (var actualId in actualResult) {
           if (!result.containsKey(actualId.name)) return false;
           var expectedId = result.remove(actualId.name);
           if (actualId != expectedId) return false;
         }
         return result.isEmpty;
       }, 'packages to match $result')));
-    } else if (error == noVersion) {
-      expect(future, throwsA(isNoVersionException));
-    } else if (error == disjointConstraint) {
-      expect(future, throwsA(isDisjointConstraintException));
-    } else if (error == sourceMismatch) {
-      expect(future, throwsA(isSourceMismatchException));
-    } else if (error == descriptionMismatch) {
-      expect(future, throwsA(isDescriptionMismatchException));
-    } else if (error == couldNotSolve) {
-      expect(future, throwsA(isCouldNotSolveException));
-    } else {
+    } else if (error != null) {
       expect(future, throwsA(error));
     }
 
     // If we aren't expecting an error, print some debugging info if we get one.
     if (error == null) {
       future.handleException((ex) {
         print(ex);
         print(future.stackTrace);
         return true;
       });
@@ skipping 94 matching lines @@
   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], rootSource);
   case 'versionless':
     return new Pair<String, Source>(match[1], versionlessSource);
   }
 }