Split AssetGraph.results into two streams.

pkg/barback/test/utils.dart

 // Copyright (c) 2013, 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 barback.test.utils;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
@@ skipping 88 matching lines @@
   schedule(() =>_provider._pause(), "pause provider");
 }
 
 /// Schedules an unpause of the provider after a call to [pauseProvider] and
 /// allows all pending asset loads to finish.
 void resumeProvider() {
   schedule(() => _provider._resume(), "resume provider");
 }
 
 /// Expects that the next [BuildResult] is a build success.
-void buildShouldSucceed([void callback()]) {
+void buildShouldSucceed() {
   expect(_graph.results.elementAt(_nextBuildResult++).then((result) {
     expect(result.succeeded, isTrue);
-    if (callback != null) callback();
   }), completes);
 }
 
 /// Expects that the next [BuildResult] emitted is a failure.
 ///
-/// Invokes [callback] with the error (not the result) so that it can provide
-/// more precise expectations.
-void buildShouldFail(void callback(error)) {
+/// [matchers] is a list of matchers to match against the errors that caused the
+/// build to fail. Every matcher is expected to match an error, but the order of
+/// matchers is unimportant.
+void buildShouldFail(List matchers) {
   expect(_graph.results.elementAt(_nextBuildResult++).then((result) {
     expect(result.succeeded, isFalse);
-    callback(result.error);
+    expect(result.errors.length, equals(matchers.length));
+    for (var matcher in matchers) {
+      expect(result.errors, contains(matcher));
+    }
   }), completes);
 }
 
 /// Pauses the schedule until the currently running build completes.
 ///
 /// Validates that the build completed successfully.
 void waitForBuild() {
   schedule(() {
     return _graph.results.first.then((result) {
       expect(result.succeeded, isTrue);
@@ skipping 32 matching lines @@
   schedule(() {
     return _graph.getAssetById(id).then((asset) {
       fail("Should have thrown error but got $asset.");
     }).catchError((error) {
       expect(error, new isInstanceOf<AssetNotFoundException>());
       expect(error.id, equals(id));
     });
   }, "get asset $name");
 }
 
-/// Expects that the next [BuildResult] is an output file collision error on an
-/// asset matching [name].
-Future expectCollision(String name) {
-  var id = new AssetId.parse(name);
-  _graph.results.first.then(wrapAsync((result) {
-    expect(result.error, new isInstanceOf<AssetCollisionException>());
-    expect(result.error.id, equals(id));
-  }));
-}
-
 /// Schedules an expectation that [graph] will have an error on an asset
 /// matching [name] for missing [input].
 Future expectMissingInput(AssetGraph graph, String name, String input) {
   var missing = new AssetId.parse(input);
 
   // Make sure the future gets the error.
   schedule(() {
     return graph.getAssetById(new AssetId.parse(name)).then((asset) {
       fail("Should have thrown error but got $asset.");
     }).catchError((error) {
       expect(error, new isInstanceOf<MissingInputException>());
       expect(error.id, equals(missing));
     });
   }, "get missing input on $name");
 }
 
+/// Returns a matcher for an [AssetNotFoundException] with the given [id].
+Matcher isAssetNotFoundException(String name) {
+  var id = new AssetId.parse(name);
+  return allOf(
+      new isInstanceOf<AssetNotFoundException>(),
+      predicate((error) => error.id == id, 'id is $name'));
+}
+
+/// Returns a matcher for an [AssetCollisionException] with the given [id].
+Matcher isAssetCollisionException(String name) {
+  var id = new AssetId.parse(name);
+  return allOf(
+      new isInstanceOf<AssetCollisionException>(),
+      predicate((error) => error.id == id, 'id is $name'));
+}
+
+/// Returns a matcher for a [MissingInputException] with the given [id].
+Matcher isMissingInputException(String name) {
+  var id = new AssetId.parse(name);
+  return allOf(
+      new isInstanceOf<MissingInputException>(),
+      predicate((error) => error.id == id, 'id is $name'));
+}
+
 /// An [AssetProvider] that provides the given set of assets.
 class MockProvider implements AssetProvider {
   Iterable<String> get packages => _packages.keys;
 
   final _packages = new Map<String, List<MockAsset>>();
 
   /// The completer that [getAsset()] is waiting on to complete when paused.
   ///
   /// If `null` it will return the asset immediately.
   Completer _pauseCompleter;
@@ skipping 246 matching lines @@
 
   MockAsset(this.id, this.contents);
 
   Future<String> readAsString({Encoding encoding}) =>
       new Future.value(contents);
 
   Stream<List<int>> read() => throw new UnimplementedError();
 
   String toString() => "MockAsset $id $contents";
 }