Clean up barback tests.

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 'package:barback/barback.dart';
 import 'package:barback/src/asset_graph.dart';
 import 'package:pathos/path.dart' as pathos;
 import 'package:scheduled_test/scheduled_test.dart';
 
 // TODO(rnystrom): Get rid of this or find a better path for it.
 import '../../../sdk/lib/_internal/pub/test/command_line_config.dart';
 
 var _configured = false;
 
+MockProvider _provider;
+AssetGraph _graph;
+
+/// [BuildResult]s that have been output by the graph before an expectation has
+/// consumed them.
+///
+/// Since [AssetGraph] starts building immediately in the background, results
+/// may start streaming before we've set an explicit expectation. When that
+/// occurs, we just queue them up here.
+final _buildResults = new Queue<BuildResult>();
+
+/// The expectations we have on upcoming [BuildResult]s.
+final _buildExpectations = new Queue<Completer<BuildResult>>();
+
 void initConfig() {
   if (_configured) return;
   _configured = true;
   unittestConfiguration = new CommandLineConfiguration();
 }
 
-/// Expects that [graph] will return an asset matching [name] and [contents].
-void expectAsset(AssetGraph graph, String name, [String contents]) {
+/// Creates a new [AssetProvider] and [AssetGraph] with the given [assets] and
+/// [transformers].
+///
+/// This graph is used internally by most of the other functions in this
+/// library so you must call it in the test before calling any of the other
+/// functions. These other functions are automatically scheduled, with the

[nweiz, 2013/06/27 00:19:25]

"These other functions" is unclear, especially since there are functions in this
file unrelated to this change that aren't scheduled. I think it makes the most
sense to just mention in each function's documentation that it's scheduled.

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+/// exception of [updateSources] and [removeSources].
+///
+/// [assets] may either be an [Iterable] or a [Map]. If an [Iterable], each

[nweiz, 2013/06/27 00:19:25]

"If an" -> "If it's an"

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+/// element may either be an [AssetId] or a string that can be parsed to one.
+/// If it's a [Map], each key should be a string that can be parsed to an
+/// [AssetId] and the value is a string defining the contents of that asset.

[nweiz, 2013/06/27 00:19:25]

"value is" -> "value should be"

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+void initGraph([assets, Iterable<Iterable<Transformer>> transformers]) {
+  if (assets == null) assets = [];
+  if (transformers == null) transformers = [];
+
+  _provider = new MockProvider(assets);
+  _graph = new AssetGraph(_provider, transformers);
+
+  _graph.results.listen(wrapAsync((result) {
+    if (_buildExpectations.isEmpty) {
+      // We aren't waiting for a result yet, so just queue it up for later.
+      _buildResults.add(result);
+    } else {
+      // See if it meets the expectation.
+      _buildExpectations.removeFirst().complete(result);
+    }
+  }));
+
+  currentSchedule.onComplete.schedule(() {
+    // Discard any unused results. It's OK for a test to not care about some
+    // build results.
+    _buildResults.clear();
+  }, "clear unused build results");
+
+  // This library should ensure that you can't move to the next test until all
+  // build expectations are processed.
+  assert(_buildExpectations.isEmpty);
+}
+
+/// Updates [assets] in the current [AssetProvider].
+///
+/// Each item in the list may either be an [AssetId] or a string that can be
+/// parsed as one. Note that this method is not automatically scheduled, so you
+/// will typically wrap it in a call to [schedule] yourself.

[nweiz, 2013/06/27 00:19:25]

"you will typically wrap it" is confusing. Most of your tests don't schedule
this. If they did, then it seems like it should be automatically scheduled.

Same goes for [removeSources].

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+///
+void updateSources(Iterable assets) {
+  // Allow strings as asset IDs.
+  assets = assets.map((asset) {
+    if (asset is String) return new AssetId.parse(asset);
+    return asset;
+  });
+
+  _graph.updateSources(assets);
+}
+
+/// Removes [assets] from the current [AssetProvider].
+///
+/// Each item in the list may either be an [AssetId] or a string that can be
+/// parsed as one. Note that this method is not automatically scheduled, so you
+/// will typically wrap it in a call to [schedule] yourself.
+void removeSources(Iterable assets) {
+  // Allow strings as asset IDs.
+  assets = assets.map((asset) {
+    if (asset is String) return new AssetId.parse(asset);
+    return asset;
+  });
+
+  _graph.removeSources(assets);
+}
+
+/// Changes the contents of an asset identified by [name] to [contents].
+///
+/// Does not update it in the graph.
+void modifyAsset(String name, String contents) {
+  schedule(() {
+    _provider._modifyAsset(name, contents);
+  }, "modify asset $name");
+}
+
+/// Pauses the internally created [AssetProvider]. All asset requests that the

[nweiz, 2013/06/27 00:19:25]

Paragraph break

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+/// [AssetGraph] makes to the provider after this will not complete until
+/// [resumeProvider] is called.
+void pauseProvider() {
+  schedule(() =>_provider._pause(), "resume provider");

[nweiz, 2013/06/27 00:19:25]

"resume" -> "pause"

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+}
+
+/// Unpauses the provider after a call to [pauseProvider] and allows all
+/// pending asset loads to finish.
+void resumeProvider() {
+  schedule(() => _provider._resume(), "pause provider");

[nweiz, 2013/06/27 00:19:25]

"pause" -> "resume"

[Bob Nystrom, 2013/06/27 17:55:14]

Done.

+}
+
+/// Waits for the next [BuildResult] to be emitted and asserts that it is a
+/// build success.
+void buildShouldSucceed() {
+  schedule(() {
+    return _getNextBuildResult().then((result) {
+      expect(result.succeeded, isTrue);
+    });
+  }, "wait for build to succeed");
+}
+
+/// Waits for the next [BuildResult] to be emitted and asserts that it is a
+/// build failure. Invokes [callback] with the error (not the result) so that
+/// it can provide more precise expectations.
+void buildShouldFail(void callback(error)) {
+  schedule(() {
+    return _getNextBuildResult().then((result) {
+      expect(result.succeeded, isFalse);
+      callback(result.error);
+    });
+  }, "wait for build error");
+}
+
+Future<BuildResult> _getNextBuildResult() {
+  if (_buildResults.isNotEmpty) {
+    return new Future.value(_buildResults.removeFirst());
+  }
+
+  // We don't have any results yet, so enqueue the expectation.
+  var completer = new Completer<BuildResult>();
+  _buildExpectations.add(completer);
+  return completer.future;
+}
+
+/// Expects that the graph will deliver an asset matching [name] and [contents].
+///
+/// If [contents] is omitted, defaults to the asset's filename without an
+/// extension (which is the same default that [initGraph] uses).
+void expectAsset(String name, [String contents]) {
   var id = new AssetId.parse(name);
 
   if (contents == null) {
     contents = pathos.basenameWithoutExtension(id.path);
   }
 
   schedule(() {
-    return graph.getAssetById(id).then((asset) {
+    return _graph.getAssetById(id).then((asset) {
       // TODO(rnystrom): Make an actual Matcher class for this.
       expect(asset, new isInstanceOf<MockAsset>());
       expect(asset._id.package, equals(id.package));
       expect(asset._id.path, equals(id.path));
       expect(asset._contents, equals(contents));
     });
   }, "get asset $name");
 }
 
-/// Expects that [graph] will not find an asset matching [name].
-void expectNoAsset(AssetGraph graph, String name) {
+/// Expects that the graph will not find an asset matching [name].
+void expectNoAsset(String name) {
   var id = new AssetId.parse(name);
 
   // Make sure the future gets the error.
   schedule(() {
-    return graph.getAssetById(id).then((asset) {
+    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 [graph] will have an output file collision error on an asset
+/// Expects that the graph will have an output file collision error on an asset
 /// matching [name].
-Future expectCollision(AssetGraph graph, String name) {
+Future expectCollision(String name) {
   var id = new AssetId.parse(name);
   return schedule(() {
-    return graph.results.first.then((result) {
+    return _graph.results.first.then((result) {
       expect(result.error, new isInstanceOf<AssetCollisionException>());
       expect(result.error.id, equals(id));
     });
   }, "get collision on $name");
 }
 
 /// Expects 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");
 }
 
 /// 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.
+  /// The completer that [getAsset()] is waiting on to complete when paused.
   ///
   /// If `null` it will return the asset immediately.
-  Completer _wait;
+  Completer _pauseCompleter;
 
   /// Tells the provider to wait during [getAsset] until [complete()]
   /// is called.
   ///
   /// Lets you test the asynchronous behavior of loading.
-  void wait() {
-    _wait = new Completer();
+  void _pause() {
+    _pauseCompleter = new Completer();
   }
 
-  void complete() {
-    _wait.complete();
-    _wait = null;
+  void _resume() {
+    _pauseCompleter.complete();
+    _pauseCompleter = null;
   }
 
   MockProvider(assets) {
     if (assets is Map) {
       assets.forEach((asset, contents) {
         var id = new AssetId.parse(asset);
         var package = _packages.putIfAbsent(id.package, () => []);
         package.add(new MockAsset(id, contents));
       });
     } else if (assets is Iterable) {
       for (var asset in assets) {
         var id = new AssetId.parse(asset);
         var package = _packages.putIfAbsent(id.package, () => []);
         var contents = pathos.basenameWithoutExtension(id.path);
         package.add(new MockAsset(id, contents));
       }
     }
   }
 
-  void modifyAsset(String name, String contents) {
+  void _modifyAsset(String name, String contents) {
     var id = new AssetId.parse(name);
     var asset = _packages[id.package].firstWhere((a) => a._id == id);
     asset._contents = contents;
   }
 
   List<AssetId> listAssets(String package, {String within}) {
     if (within != null) {
       throw new UnimplementedError("Doesn't handle 'within' yet.");
     }
 
     return _packages[package].map((asset) => asset.id);
   }
 
   Future<Asset> getAsset(AssetId id) {
     var future;
-    if (_wait != null) {
-      future = _wait.future;
+    if (_pauseCompleter != null) {
+      future = _pauseCompleter.future;
     } else {
       future = new Future.value();
     }
 
     return future.then((_) {
       var package = _packages[id.package];
       if (package == null) throw new AssetNotFoundException(id);
 
       return package.firstWhere((asset) => asset._id == id,
           orElse: () => throw new AssetNotFoundException(id));
@@ skipping 177 matching lines @@
 
   MockAsset(this._id, this._contents);
 
   String readAsString() => _contents;
   Stream<List<int>> read() => throw new UnimplementedError();
 
   serialize() => throw new UnimplementedError();
 
   String toString() => "MockAsset $_id $_contents";
 }