Support cross-package transforms in barback.

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_cascade.dart';
 import 'package:barback/src/asset_set.dart';
 import 'package:barback/src/cancelable_future.dart';
-import 'package:barback/src/package_graph.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';
 export 'transformer/many_to_one.dart';
 export 'transformer/mock.dart';
 export 'transformer/one_to_many.dart';
 export 'transformer/rewrite.dart';
 
 var _configured = false;
 
 MockProvider _provider;
-PackageGraph _graph;
+Barback _barback;
 
 /// Calls to [buildShouldSucceed] and [buildShouldFail] set expectations on
-/// successive [BuildResult]s from [_graph]. This keeps track of how many calls
-/// have already been made so later calls know which result to look for.
+/// successive [BuildResult]s from [_barback]. This keeps track of how many
+/// calls have already been made so later calls know which result to look for.
 int _nextBuildResult;
 
 void initConfig() {
   if (_configured) return;
   _configured = true;
   useCompactVMConfiguration();
 }
 
 /// Creates a new [PackageProvider] and [PackageGraph] 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.
 ///
 /// [assets] may either be an [Iterable] or a [Map]. If it's an [Iterable],
 /// each 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 should be a string defining the contents of that
 /// asset.
 ///
 /// [transformers] is a map from package names to the transformers for each
 /// package.
 void initGraph([assets,
     Map<String, Iterable<Iterable<Transformer>>> transformers]) {
   if (assets == null) assets = [];
   if (transformers == null) transformers = {};
 
   _provider = new MockProvider(assets, transformers);
-  _graph = new PackageGraph(_provider);
+  _barback = new Barback(_provider);
   _nextBuildResult = 0;
 }
 
 /// Updates [assets] in the current [PackageProvider].
 ///
 /// 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.
 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);
+  _barback.updateSources(assets);
 }
 
 /// Removes [assets] from the current [PackageProvider].
 ///
 /// 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.
 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);
+  _barback.removeSources(assets);
 }
 
 /// Schedules a change to 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");
@@ skipping 24 matching lines @@
 }
 
 /// Asserts that the current build step shouldn't have finished by this point in
 /// the schedule.
 ///
 /// This uses the same build counter as [buildShouldSucceed] and
 /// [buildShouldFail], so those can be used to validate build results before and
 /// after this.
 void buildShouldNotBeDone() {
   _futureShouldNotCompleteUntil(
-      _graph.results.elementAt(_nextBuildResult),
+      _barback.results.elementAt(_nextBuildResult),
       schedule(() => pumpEventQueue(), "build should not terminate"),
       "build");
 }
 
 /// Expects that the next [BuildResult] is a build success.
 void buildShouldSucceed() {
   expect(_getNextBuildResult().then((result) {
     result.errors.forEach(currentSchedule.signalError);
     expect(result.succeeded, isTrue);
   }), completes);
 }
 
 /// Expects that the next [BuildResult] emitted is a failure.
 ///
 /// [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(_getNextBuildResult().then((result) {
     expect(result.succeeded, isFalse);
     expect(result.errors.length, equals(matchers.length));
     for (var matcher in matchers) {
       expect(result.errors, contains(matcher));
     }
   }), completes);
 }
 
 Future<BuildResult> _getNextBuildResult() =>
-  _graph.results.elementAt(_nextBuildResult++);
+  _barback.results.elementAt(_nextBuildResult++);
 
 /// Pauses the schedule until the currently running build completes.
 ///
 /// Validates that the build completed successfully.
 void waitForBuild() {
   schedule(() {
-    return _graph.results.first.then((result) {
+    return _barback.results.first.then((result) {
       expect(result.succeeded, isTrue);
     });
   }, "wait for build");
 }
 
 /// Schedules an expectation 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 _barback.getAssetById(id).then((asset) {
       // TODO(rnystrom): Make an actual Matcher class for this.
       expect(asset.id, equals(id));
       expect(asset.readAsString(), completion(equals(contents)));
     });
   }, "get asset $name");
 }
 
 /// Schedules an expectation 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 _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 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(
-        _graph.getAssetById(id),
+        _barback.getAssetById(id),
         pumpEventQueue(),
         "asset $id");
   }, "asset $id should not complete");
 }
 
 /// 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>(),
@@ skipping 190 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";
 }