Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(33)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/barback/test/package_graph/cluster_test.dart

Issue 25376003: Add support for transformer clusters to barback. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Expose the Operator class. Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« pkg/barback/lib/src/transformer_cluster.dart ('K') | « pkg/barback/test/package_graph/add_remove_transform_test.dart ('k') | pkg/barback/test/utils.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/barback/test/package_graph/cluster_test.dart
diff --git a/pkg/barback/test/package_graph/cluster_test.dart b/pkg/barback/test/package_graph/cluster_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..bf0bb62974975bf5d1ea644beef2a6f4393dc0d1
--- /dev/null
+++ b/pkg/barback/test/package_graph/cluster_test.dart
@@ -0,0 +1,380 @@
+// 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.package_graph.cluster_test;
+
+import 'package:barback/barback.dart';
+import 'package:scheduled_test/scheduled_test.dart';
+
+import '../utils.dart';
+
+main() {
+ initConfig();
+ test("runs transforms in a cluster", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectNoAsset("app|foo.b");
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+ });
+
+ test("passes the output of a cluster to the next phase", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])],
+ [new RewriteTransformer("c", "d")]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectNoAsset("app|foo.c");
+ expectAsset("app|foo.d", "foo.b.c.d");
+ buildShouldSucceed();
+ });
+
+ test("passes the output of a previous phase to a cluster", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new RewriteTransformer("a", "b")],
+ [new TransformerCluster([
+ [new RewriteTransformer("b", "c")],
+ [new RewriteTransformer("c", "d")]
+ ])]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectNoAsset("app|foo.b");
+ expectAsset("app|foo.d", "foo.b.c.d");
+ buildShouldSucceed();
+ });
+
+ test("intermediate assets in a cluster are usable as secondary inputs within "
+ "that cluster", () {
+ initGraph({
+ "app|foo.a": "foo",
Bob Nystrom 2013/10/04 21:47:50 Using "foo" both as the file name and content is a
nweiz 2013/10/07 23:21:31 Done. I did that because that's the default conten
+ "app|bar.txt": "foo.inc"
+ }, {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "inc")],
+ [new ManyToOneTransformer("txt")]
+ ])]
+ ]});
+
+ updateSources(["app|foo.a", "app|bar.txt"]);
+ expectAsset("app|bar.out", "foo.inc");
+ buildShouldSucceed();
+ });
+
+ test("clusters can be nested", () {
+ initGraph(["app|foo.a", "app|bar.x"], {"app": [
+ [new TransformerCluster([
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new TransformerCluster([
+ [new RewriteTransformer("x", "y"), new RewriteTransformer("a", "y")],
+ [new RewriteTransformer("y", "z")]
+ ])],
+ [new RewriteTransformer("c", "d")]
+ ])]
+ ]});
+ updateSources(["app|foo.a", "app|bar.x"]);
+ expectAsset("app|foo.d", "foo.b.c.d");
+ expectAsset("app|foo.z", "foo.y.z");
+ expectAsset("app|bar.z", "bar.y.z");
+ buildShouldSucceed();
+ });
+
+ test("an updated asset is propagated through a cluster", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]});
+
+ updateSources(["app|foo.a"]);
+ expectNoAsset("app|foo.b");
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+
+ modifyAsset("app|foo.a", "new foo");
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.c", "new foo.b.c");
+ buildShouldSucceed();
+ });
+
+ test("an updated asset only runs the necessary transforms in a cluster",
+ () {
+ var rewriteA = new RewriteTransformer("a", "b");
+ var rewriteX = new RewriteTransformer("x", "b");
+ initGraph(["app|foo.a", "app|bar.x"], {"app": [
+ [new TransformerCluster([
+ [rewriteA, rewriteX],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]});
+
+ updateSources(["app|foo.a", "app|bar.x"]);
+ expectNoAsset("app|foo.b");
+ expectAsset("app|foo.c", "foo.b.c");
+ expectAsset("app|bar.c", "bar.b.c");
+ buildShouldSucceed();
+
+ modifyAsset("app|foo.a", "new foo");
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.c", "new foo.b.c");
+ buildShouldSucceed();
+
+ expect(rewriteA.numRuns, completion(equals(2)));
+ expect(rewriteX.numRuns, completion(equals(1)));
+ });
+
+ group("encapsulation", () {
+ test("a cluster can't see a parallel transform's outputs", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("x", "b")]
Bob Nystrom 2013/10/04 21:47:50 Nit but can you move "new Rewrite..." to its own l
nweiz 2013/10/07 23:21:31 Done.
+ ]});
+ updateSources(["app|foo.x"]);
+ expectAsset("app|foo.b", "foo.b");
+ expectNoAsset("app|foo.c");
+ buildShouldSucceed();
+ });
+
+ test("a parallel transform can't see a cluster's outputs", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("c", "z")]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.c", "foo.b.c");
+ expectNoAsset("app|foo.z");
+ buildShouldSucceed();
+ });
+
+ test("a parallel transform can't see a cluster's intermediate assets", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("b", "z")]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.c", "foo.b.c");
+ expectNoAsset("app|foo.z");
+ buildShouldSucceed();
+ });
+
+ test("parallel clusters can't see one another's intermediate assets", () {
Bob Nystrom 2013/10/04 21:47:50 What happens if intermediates in two clusters coll
nweiz 2013/10/07 23:21:31 Done.
+ initGraph(["app|foo.a", "app|bar.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new TransformerCluster([
+ [new RewriteTransformer("x", "b")],
+ [new RewriteTransformer("b", "z")]
+ ])]
+ ]});
+ updateSources(["app|foo.a", "app|bar.x"]);
+ expectAsset("app|foo.c", "foo.b.c");
+ expectAsset("app|bar.z", "bar.b.z");
+ expectNoAsset("app|foo.z");
+ expectNoAsset("app|bar.c");
+ buildShouldSucceed();
+ });
+ });
+
+ group("pass-through", () {
+ test("passes an unused input through a cluster", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]});
+ updateSources(["app|foo.x"]);
+ expectNoAsset("app|foo.c");
+ expectAsset("app|foo.x", "foo");
+ buildShouldSucceed();
+ });
+
+ test("passes an unused input through parallel clusters", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new TransformerCluster([
+ [new RewriteTransformer("1", "2")],
+ [new RewriteTransformer("2", "3")]
+ ])]
+ ]});
+ updateSources(["app|foo.x"]);
+ expectNoAsset("app|foo.c");
+ expectNoAsset("app|foo.3");
+ expectAsset("app|foo.x", "foo");
+ buildShouldSucceed();
+ });
+
+ test("passes an unused input through a cluster and a transform", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("1", "2")]
+ ]});
+ updateSources(["app|foo.x"]);
+ expectNoAsset("app|foo.c");
+ expectNoAsset("app|foo.2");
+ expectAsset("app|foo.x", "foo");
+ buildShouldSucceed();
+ });
+
+ test("doesn't pass through an input that's used by a cluster but not by "
+ "transformers", () {
+ initGraph(["app|foo.a"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("x", "y")]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectNoAsset("app|foo.a");
+ expectNoAsset("app|foo.y");
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+ });
+
+ test("doesn't pass through an input that's used by transformers but not by "
+ "a cluster", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("x", "y")]
+ ]});
+ updateSources(["app|foo.x"]);
+ expectNoAsset("app|foo.x");
+ expectNoAsset("app|foo.c");
+ expectAsset("app|foo.y", "foo.y");
+ buildShouldSucceed();
+ });
+
+ test("doesn't detect a collision for an input that's modified in-place by "
+ "a transformer", () {
+ initGraph(["app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("x", "x")]
+ ]});
+ updateSources(["app|foo.x"]);
+ expectAsset("app|foo.x", "foo.x");
+ buildShouldSucceed();
+ });
+
+ test("doesn't detect a collision for an input that's modified in-place by "
+ "a cluster", () {
+ initGraph(["app|foo.a"], {"app": [
+ [
+ new TransformerCluster([[new RewriteTransformer("a", "a")]]),
+ new RewriteTransformer("x", "y")
+ ]
+ ]});
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.a", "foo.a");
+ buildShouldSucceed();
+ });
+ });
+
+ test("runs transforms in an added cluster", () {
+ var rewrite = new RewriteTransformer("a", "z");
+ initGraph(["app|foo.a"], {"app": [[rewrite]]});
+
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.z", "foo.z");
+ buildShouldSucceed();
+
+ updateOperators("app", [
+ [rewrite, new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]);
Bob Nystrom 2013/10/04 21:47:50 Style nit, but I think this is a better: updateOp
nweiz 2013/10/07 23:21:31 Done.
+ expectAsset("app|foo.z", "foo.z");
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+ });
+
+ test("doesn't re-run transforms in a re-added cluster", () {
+ var rewrite1 = new RewriteTransformer("a", "b");
+ var rewrite2 = new RewriteTransformer("b", "c");
+ var cluster = new TransformerCluster([[rewrite1], [rewrite2]]);
+ initGraph(["app|foo.a"], {"app": [[cluster]]});
+
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+
+ updateOperators("app", [
+ [cluster, new RewriteTransformer("a", "z")]
+ ]);
+ expectAsset("app|foo.c", "foo.b.c");
+ expectAsset("app|foo.z", "foo.z");
+ buildShouldSucceed();
+
+ expect(rewrite1.numRuns, completion(equals(1)));
+ expect(rewrite2.numRuns, completion(equals(1)));
+ });
+
+ test("doesn't pass through an input that's used by an added cluster", () {
+ var rewrite = new RewriteTransformer("x", "z");
+ initGraph(["app|foo.a"], {"app": [[rewrite]]});
+
+ updateSources(["app|foo.a"]);
+ expectAsset("app|foo.a", "foo");
+ buildShouldSucceed();
+
+ updateOperators("app", [
+ [rewrite, new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ])]
+ ]);
+ expectNoAsset("app|foo.a");
+ expectAsset("app|foo.c", "foo.b.c");
+ buildShouldSucceed();
+ });
+
+ // TODO(nweiz): make the collision error message nice
+ test("reports collisions within a cluster", () {
+ initGraph(["app|foo.a", "app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("x", "b")]
+ ])]
+ ]});
+ updateSources(["app|foo.a", "app|foo.x"]);
+ buildShouldFail([isAssetCollisionException("app|foo.b")]);
+ });
+
+ test("reports collisions between a cluster and a non-clustered transform",
+ () {
+ initGraph(["app|foo.a", "app|foo.x"], {"app": [
+ [new TransformerCluster([
+ [new RewriteTransformer("a", "b")],
+ [new RewriteTransformer("b", "c")]
+ ]), new RewriteTransformer("x", "c")]
+ ]});
+ updateSources(["app|foo.a", "app|foo.x"]);
+ buildShouldFail([isAssetCollisionException("app|foo.c")]);
+ });
+}
« pkg/barback/lib/src/transformer_cluster.dart ('K') | « pkg/barback/test/package_graph/add_remove_transform_test.dart ('k') | pkg/barback/test/utils.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698