Start sketching out a buildAll() method.

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';
 
 import 'package:barback/barback.dart';
-import 'package:barback/src/asset_set.dart';
 import 'package:barback/src/cancelable_future.dart';
 import 'package:barback/src/utils.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:scheduled_test/scheduled_test.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:unittest/compact_vm_config.dart';
 
 export 'transformer/bad.dart';
 export 'transformer/check_content.dart';
 export 'transformer/create_asset.dart';
@@ skipping 193 matching lines @@
   schedule(() {
     return _barback.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");
 }
 
+/// Schedules an expectation that the graph will output all of the given
+/// assets, and no others.
+///
+/// [assets] is a list of strings that can be parsed to [AssetID]s.
+void expectAllAssets(Iterable<String> assets) {
+  schedule(() {
+    return _barback.getAllAssets().then((actualAssets) {
+      var actualIds = actualAssets.map((asset) => asset.id).toSet();
+
+      for (var expected in assets) {
+        var id = new AssetId.parse(expected);

[nweiz, 2013/08/20 19:59:26]

Parse these outside of [schedule] so that parse errors will be reported
synchronously and you can include them in the schedule description.

[Bob Nystrom, 2013/08/20 21:29:20]

Done.

+        expect(actualIds, contains(id));
+        actualIds.remove(id);
+      }
+
+      expect(actualIds, isEmpty);
+    });
+  }, "get all assets");
+}
+
+/// Schedules an expectation that [Barback.getAllAssets] will return a [Future]
+/// that completes to a error that matches [match].
+///
+/// If [match] is a [List], then it expects the completed error to be an
+/// [AggregateException] whose errors match each matcher in the list. Otherwise,
+/// [match] should be a single matcher that the error should match.

[nweiz, 2013/08/20 19:59:26]

It seems weird to have a one-off special case for AggregateException. Eventually
we're going to want to start matching AggregateExceptions anywhere a
BarbackException might be thrown. It seems cleaner to create an
isAggregateException matcher.

That also makes this implementation a lot simpler:

    expect(_barback.getAllAssets(), throwsA(matcher))

[Bob Nystrom, 2013/08/20 21:29:20]

Done. The implementation of isAggregateError() feels a bit wonky, but I don't
have a good feel for when I should compose matchers versus actually just writing
a matcher class from scratch.

+void expectAllAssetsShouldFail(match) {
+  schedule(() {
+    return expect(_barback.getAllAssets().catchError((error) {

[nweiz, 2013/08/20 19:59:26]

Returning expect doesn't do anything.

[Bob Nystrom, 2013/08/20 21:29:20]

Done.

+      if (match is List) {
+        expect(error, new isInstanceOf<AggregateException>());
+        expect(error.errors.length, equals(match.length));
+        for (var matcher in match) {
+          expect(error.errors, contains(matcher));
+        }
+      } else {
+        expect(error, match);
+      }
+
+      throw error;
+    }), throwsA(new isInstanceOf<BarbackException>()));
+  }, "get all assets should fail");
+}
+
 /// Schedules an expectation that a [getAssetById] call for the given asset
 /// won't terminate at this point in the schedule.
 void expectAssetDoesNotComplete(String name) {
   var id = new AssetId.parse(name);
 
   schedule(() {
     return _futureShouldNotCompleteUntil(
         _barback.getAssetById(id),
         pumpEventQueue(),
         "asset $id");
@@ skipping 236 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";
 }