Clean up barback tests.

pkg/barback/lib/src/asset_graph.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.asset_graph;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
 import 'asset_id.dart';
 import 'asset_provider.dart';
 import 'errors.dart';
 import 'change_batch.dart';
 import 'phase.dart';
 import 'transformer.dart';
 
 /// The main build dependency manager.
 ///
 /// For any given input file, it can tell which output files are affected by
 /// it, and vice versa.
 class AssetGraph {
   final AssetProvider _provider;
 
   final _phases = <Phase>[];
 
-  Stream<ProcessResult> get results => _resultsController.stream;
-  final _resultsController = new StreamController<ProcessResult>.broadcast();
+  Stream<BuildResult> get results => _resultsController.stream;
+  final _resultsController = new StreamController<BuildResult>.broadcast();
 
   /// A future that completes when the currently running build process finishes.
   ///
   /// If no build it in progress, is `null`.
   Future _processDone;
 
   ChangeBatch _sourceChanges;
 
   /// Creates a new [AssetGraph].
   ///
@@ skipping 48 matching lines @@
       for (var i = _phases.length - 1; i >= 0; i--) {
         var node = _phases[i].inputs[id];
         if (node != null) {
           // By the time we get here, the asset should have been built.
           assert(node.asset != null);
           return node.asset;
         }
       }
 
       // Couldn't find it.
-      var error = new AssetNotFoundException(id);
-      reportError(error);
-      throw error;
+      throw new AssetNotFoundException(id);
     });
   }
 
   /// Adds [sources] to the graph's known set of source assets.
   ///
   /// Begins applying any transforms that can consume any of the sources. If a
   /// given source is already known, it is considered modified and all
   /// transforms that use it will be re-applied.
   void updateSources(Iterable<AssetId> sources) {
     if (_sourceChanges == null) _sourceChanges = new ChangeBatch();
     _sourceChanges.update(sources);
 
     _waitForProcess();
   }
 
   /// Removes [removed] from the graph's known set of source assets.
   void removeSources(Iterable<AssetId> removed) {
     if (_sourceChanges == null) _sourceChanges = new ChangeBatch();
     _sourceChanges.remove(removed);
 
     _waitForProcess();
   }
 
   /// Reports a process result with the given error then throws it.
   void reportError(error) {
-    _resultsController.add(new ProcessResult(error));
+    _resultsController.add(new BuildResult(error));
   }
 
   /// Starts the build process asynchronously if there is work to be done.
   ///
   /// Returns a future that completes with the background processing is done.
   /// If there is no work to do, returns a future that completes immediately.
   /// All errors that occur during processing will be caught (and routed to the
   /// [results] stream) before they get to the returned future, so it is safe
   /// to discard it.
   Future _waitForProcess() {
     if (_processDone != null) return _processDone;
-    return _processDone = _process().catchError((error) {
+    return _processDone = _process().then((_) {
+      // Report the build completion.
+      // TODO(rnystrom): Put some useful data in here.
+      _resultsController.add(new BuildResult());
+    }).catchError((error) {
       // If we get here, it's an unexpected error. Runtime errors like missing
       // assets should be handled earlier. Errors from transformers or other
       // external code that barback calls into should be caught at that API
       // boundary.
       //
       // On the off chance we get here, pipe the error to the results stream
       // as an error. That will let applications handle it without it appearing
       // in the same path as "normal" errors that get reported.
       _resultsController.addError(error);
     }).whenComplete(() {
       _processDone = null;
-      // Report the build completion.
-      // TODO(rnystrom): Put some useful data in here.
-      _resultsController.add(new ProcessResult());
     });
   }
 
   /// Starts the background processing.
   ///
   /// Returns a future that completes when all assets have been processed.
   Future _process() {
     return _processSourceChanges().then((_) {
       // Find the first phase that has work to do and do it.
       var future;
@@ skipping 48 matching lines @@
 
       return Future.wait(futures).then((_) {
         _phases.first.updateInputs(updated, changes.removed);
       });
     });
   }
 }
 
 /// Used to report build results back from the asynchronous build process
 /// running in the background.
-class ProcessResult {
+class BuildResult {
   /// The error that occurred, or `null` if the result is not an error.
   final error;
 
-  ProcessResult([this.error]);
+  /// `true` if this result is for a successful build.
+  bool get succeeded => error == null;
+
+  BuildResult([this.error]);
 }