| // 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.group_test; |
| |
| import 'dart:async'; |
| |
| import 'package:barback/barback.dart'; |
| import 'package:scheduled_test/scheduled_test.dart'; |
| |
| import '../utils.dart'; |
| |
| main() { |
| initConfig(); |
| test("runs transforms in a group", () { |
| initGraph(["app|foo.a"], {"app": [ |
| [new TransformerGroup([ |
| [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 group to the next phase", () { |
| initGraph(["app|foo.a"], {"app": [ |
| [new TransformerGroup([ |
| [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 group", () { |
| initGraph(["app|foo.a"], {"app": [ |
| [new RewriteTransformer("a", "b")], |
| [new TransformerGroup([ |
| [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 group are usable as secondary inputs within " |
| "that group", () { |
| initGraph({ |
| "app|foo.a": "contents", |
| "app|bar.txt": "foo.inc" |
| }, {"app": [ |
| [new TransformerGroup([ |
| [new RewriteTransformer("a", "inc")], |
| [new ManyToOneTransformer("txt")] |
| ])] |
| ]}); |
| |
| updateSources(["app|foo.a", "app|bar.txt"]); |
| expectAsset("app|bar.out", "contents.inc"); |
| buildShouldSucceed(); |
| }); |
| |
| test("groups can be nested", () { |
| initGraph(["app|foo.a", "app|bar.x"], {"app": [ |
| [new TransformerGroup([ |
| [new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), new TransformerGroup([ |
| [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 group", () { |
| initGraph(["app|foo.a"], {"app": [ |
| [new TransformerGroup([ |
| [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 group", () { |
| var rewriteA = new RewriteTransformer("a", "b"); |
| var rewriteX = new RewriteTransformer("x", "b"); |
| initGraph(["app|foo.a", "app|bar.x"], {"app": [ |
| [new TransformerGroup([ |
| [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 group can't see a parallel transform's outputs", () { |
| initGraph(["app|foo.x"], {"app": [[ |
| new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), |
| new RewriteTransformer("x", "b") |
| ]]}); |
| updateSources(["app|foo.x"]); |
| expectAsset("app|foo.b", "foo.b"); |
| expectNoAsset("app|foo.c"); |
| buildShouldSucceed(); |
| }); |
| |
| test("a parallel transform can't see a group's outputs", () { |
| initGraph(["app|foo.a"], {"app": [[ |
| new TransformerGroup([ |
| [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 group's intermediate assets", () { |
| initGraph(["app|foo.a"], {"app": [[ |
| new TransformerGroup([ |
| [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 groups can't see one another's intermediate assets", () { |
| initGraph(["app|foo.a", "app|bar.x"], {"app": [ |
| [new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), new TransformerGroup([ |
| [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(); |
| }); |
| |
| test("parallel groups' intermediate assets can't collide", () { |
| initGraph(["app|foo.a", "app|foo.x"], {"app": [ |
| [new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), new TransformerGroup([ |
| [new RewriteTransformer("x", "b")], |
| [new RewriteTransformer("b", "z")] |
| ])] |
| ]}); |
| updateSources(["app|foo.a", "app|foo.x"]); |
| expectAsset("app|foo.c", "foo.b.c"); |
| expectAsset("app|foo.z", "foo.b.z"); |
| buildShouldSucceed(); |
| }); |
| }); |
| |
| group("pass-through", () { |
| test("passes an unused input through a group", () { |
| initGraph(["app|foo.x"], {"app": [ |
| [new TransformerGroup([ |
| [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 groups", () { |
| initGraph(["app|foo.x"], {"app": [ |
| [new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), new TransformerGroup([ |
| [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 group and a transform", () { |
| initGraph(["app|foo.x"], {"app": [[ |
| new TransformerGroup([ |
| [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 group but not by " |
| "transformers", () { |
| initGraph(["app|foo.a"], {"app": [[ |
| new TransformerGroup([ |
| [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 group", () { |
| initGraph(["app|foo.x"], {"app": [[ |
| new TransformerGroup([ |
| [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 TransformerGroup([ |
| [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 group", () { |
| initGraph(["app|foo.a"], {"app": [[ |
| new TransformerGroup([[new RewriteTransformer("a", "a")]]), |
| new RewriteTransformer("x", "y") |
| ]]}); |
| updateSources(["app|foo.a"]); |
| expectAsset("app|foo.a", "foo.a"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't pass-through an asset that ceases to be forwarded due to a " |
| "resolved collision", () { |
| initGraph({ |
| "app|foo.a": "foo.a", |
| "app|foo.x": "foo.x" |
| }, {"app": [ |
| [new TransformerGroup([[ |
| new CheckContentAndRenameTransformer( |
| "a", "new foo.a", "z", "modified foo.a"), |
| new RewriteTransformer('x', 'a') |
| ]])] |
| ]}); |
| |
| updateSources(["app|foo.a", "app|foo.x"]); |
| expectAsset("app|foo.a", "foo.a"); |
| expectNoAsset("app|foo.z"); |
| buildShouldFail([isAssetCollisionException("app|foo.a")]); |
| |
| modifyAsset('app|foo.a', 'new foo.a'); |
| updateSources(["app|foo.a"]); |
| expectAsset("app|foo.a", "foo.x.a"); |
| expectAsset("app|foo.z", "modified foo.a"); |
| buildShouldSucceed(); |
| }); |
| }); |
| |
| test("runs transforms in an added group", () { |
| var rewrite = new RewriteTransformer("a", "z"); |
| initGraph(["app|foo.a"], {"app": [[rewrite]]}); |
| |
| updateSources(["app|foo.a"]); |
| expectAsset("app|foo.z", "foo.z"); |
| buildShouldSucceed(); |
| |
| updateTransformers("app", [[ |
| rewrite, |
| new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]) |
| ]]); |
| expectAsset("app|foo.z", "foo.z"); |
| expectAsset("app|foo.c", "foo.b.c"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't re-run transforms in a re-added group", () { |
| var rewrite1 = new RewriteTransformer("a", "b"); |
| var rewrite2 = new RewriteTransformer("b", "c"); |
| var group = new TransformerGroup([[rewrite1], [rewrite2]]); |
| initGraph(["app|foo.a"], {"app": [[group]]}); |
| |
| updateSources(["app|foo.a"]); |
| expectAsset("app|foo.c", "foo.b.c"); |
| buildShouldSucceed(); |
| |
| updateTransformers("app", [ |
| [group, 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 group", () { |
| var rewrite = new RewriteTransformer("x", "z"); |
| initGraph(["app|foo.a"], {"app": [[rewrite]]}); |
| |
| updateSources(["app|foo.a"]); |
| expectAsset("app|foo.a", "foo"); |
| buildShouldSucceed(); |
| |
| updateTransformers("app", [ |
| [rewrite, new TransformerGroup([ |
| [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 group", () { |
| initGraph(["app|foo.a", "app|foo.x"], {"app": [ |
| [new TransformerGroup([ |
| [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 group and a non-grouped transform", () { |
| initGraph(["app|foo.a", "app|foo.x"], {"app": [[ |
| new TransformerGroup([ |
| [new RewriteTransformer("a", "b")], |
| [new RewriteTransformer("b", "c")] |
| ]), |
| new RewriteTransformer("x", "c") |
| ]]}); |
| updateSources(["app|foo.a", "app|foo.x"]); |
| buildShouldFail([isAssetCollisionException("app|foo.c")]); |
| }); |
| } |