Barback transforms now pass through the primary input by default.

pkg/barback/test/package_graph/add_remove_transform_test.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.package_graph.transform_test;
 
 import 'package:barback/src/utils.dart';
 import 'package:scheduled_test/scheduled_test.dart';
 
 import '../utils.dart';
 
 main() {
   initConfig();
   test("a new transformer is applied to a matching asset", () {
     initGraph(["app|foo.blub"]);
 
     updateSources(["app|foo.blub"]);
     expectAsset("app|foo.blub", "foo");
     buildShouldSucceed();
 
     updateTransformers("app", [[new RewriteTransformer("blub", "blab")]]);
     expectAsset("app|foo.blab", "foo.blab");
-    expectNoAsset("app|foo.blub");

[Bob Nystrom, 2014/02/26 01:09:15]

How about changing these to positive expectations instead of deleting them?

[nweiz, 2014/02/26 19:37:14]

They're not really relevant to the tests they're in. The negative assertions
were relevant, in that they were another way of saying "the transformer we
expected to run did", but the positive assertions would just be duplicating the
explicit pass-through tests.

     buildShouldSucceed();
   });
 
   test("a new transformer is not applied to a non-matching asset", () {
     initGraph(["app|foo.blub"]);
 
     updateSources(["app|foo.blub"]);
     expectAsset("app|foo.blub", "foo");
     buildShouldSucceed();
 
     updateTransformers("app", [[new RewriteTransformer("zip", "zap")]]);
     expectAsset("app|foo.blub", "foo");
     expectNoAsset("app|foo.zap");
     buildShouldSucceed();
   });
 
   test("updateTransformers doesn't re-run an old transformer", () {
     var rewrite = new RewriteTransformer("blub", "blab");
     initGraph(["app|foo.blub"], {"app": [[rewrite]]});
 
     updateSources(["app|foo.blub"]);
     expectAsset("app|foo.blab", "foo.blab");
-    expectNoAsset("app|foo.blub");
     buildShouldSucceed();
 
     updateTransformers("app", [[rewrite]]);
     expectAsset("app|foo.blab", "foo.blab");
-    expectNoAsset("app|foo.blub");
     buildShouldSucceed();
 
     expect(rewrite.numRuns, completion(equals(1)));
   });
 
   test("updateTransformers re-runs old transformers in a new phase", () {
     var rewrite1 = new RewriteTransformer("txt", "blub");
     var rewrite2 = new RewriteTransformer("blub", "blab");
     initGraph(["app|foo.txt"], {"app": [[rewrite1], [rewrite2]]});
 
     updateSources(["app|foo.txt"]);
     expectAsset("app|foo.blab", "foo.blub.blab");
-    expectNoAsset("app|foo.blub");
     buildShouldSucceed();
 
     updateTransformers("app", [[rewrite2], [rewrite1]]);
     expectAsset("app|foo.blub", "foo.blub");
     expectNoAsset("app|foo.blab");
     buildShouldSucceed();
   });
 
   test("updateTransformers re-runs an old transformer when a previous phase "
       "changes", () {
@@ skipping 12 matching lines @@
     buildShouldSucceed();
   });
 
   test("a removed transformer is no longer applied", () {
     initGraph(["app|foo.blub"], {"app": [
       [new RewriteTransformer("blub", "blab")]
     ]});
 
     updateSources(["app|foo.blub"]);
     expectAsset("app|foo.blab", "foo.blab");
-    expectNoAsset("app|foo.blub");
     buildShouldSucceed();
 
     updateTransformers("app", []);
     expectAsset("app|foo.blub", "foo");
     expectNoAsset("app|foo.blab");
     buildShouldSucceed();
   });
 
   test("a new transformer is pipelined", () {
     var rewrite1 = new RewriteTransformer("source", "phase1");
@@ skipping 77 matching lines @@
 
     updateTransformers("app", [
       [rewrite, new RewriteTransformer("blib", "blob")]
     ]);
     rewrite.resumeIsPrimary("app|foo.blub");
     expectAsset("app|foo.blab", "foo.blab");
     expectAsset("app|bar.blob", "bar.blob");
     buildShouldSucceed();
   });
 
-  test("a new transformer can see pass-through assets", () {
-    var rewrite = new RewriteTransformer("zip", "zap");
-    initGraph(["app|foo.blub"], {"app": [[rewrite]]});
-
-    updateSources(["app|foo.blub"]);
-    buildShouldSucceed();
-
-    updateTransformers("app", [
-      [rewrite],
-      [new RewriteTransformer("blub", "blab")]
-    ]);
-    expectAsset("app|foo.blab", "foo.blab");
-    expectNoAsset("app|foo.blub");
-    buildShouldSucceed();
-  });
-
   test("a cross-package transform sees a new transformer in a new phase", () {
     var rewrite = new RewriteTransformer("inc", "inc");
     initGraph({
       "pkg1|foo.txt": "pkg2|foo.inc",
       "pkg2|foo.inc": "foo"
     }, {
       "pkg1": [[new ManyToOneTransformer("txt")]],
       "pkg2": [[rewrite]]
     });
 
@@ skipping 25 matching lines @@
 
     updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]);
     expectAsset("pkg1|foo.out", "foo.inc.inc");
     buildShouldSucceed();
 
     updateTransformers("pkg2", [[rewrite]]);
     expectAsset("pkg1|foo.out", "foo.inc");
     buildShouldSucceed();
   });
 
+  group("pass-through", () {
+    test("a new transformer can see pass-through assets", () {
+      var rewrite = new RewriteTransformer("zip", "zap");
+      initGraph(["app|foo.blub"], {"app": [[rewrite]]});
+
+      updateSources(["app|foo.blub"]);
+      buildShouldSucceed();
+
+      updateTransformers("app", [
+        [rewrite],
+        [new RewriteTransformer("blub", "blab")]
+      ]);
+      expectAsset("app|foo.blab", "foo.blab");
+      buildShouldSucceed();
+    });
+
+    test("a new transformer can overwrite an old asset", () {
+      var rewrite = new RewriteTransformer("zip", "zap");
+      initGraph(["app|foo.txt"], {"app": [[rewrite]]});
+
+      updateSources(["app|foo.txt"]);
+      expectAsset("app|foo.txt", "foo");
+      buildShouldSucceed();
+
+      updateTransformers("app", [
+        [rewrite, new RewriteTransformer("txt", "txt")]

[Bob Nystrom, 2014/02/26 01:09:15]

I'm not clear on what's going on here. Are you trying to show that a new
transformer will see an asset previously passed-through by an existing
transformer?

If so, shouldn't it be in a later phase?

[nweiz, 2014/02/26 19:37:14]

I'm asserting that a transform that's added to an existing phase can overwrite
an existing asset in that phase.

[Bob Nystrom, 2014/02/26 20:28:50]

OK, add some docs to clarify.

[nweiz, 2014/02/27 21:04:20]

Done.

+      ]);
+      expectAsset("app|foo.txt", "foo.txt");
+      buildShouldSucceed();
+    });
+
+    test("passes an asset through when an overwriting transform is removed",
+        () {
+      initGraph(["app|foo.txt"], {
+        "app": [[new RewriteTransformer("txt", "txt")]]
+      });
+
+      updateSources(["app|foo.txt"]);
+      expectAsset("app|foo.txt", "foo.txt");
+      buildShouldSucceed();
+
+      updateTransformers("app", [[]]);
+      expectAsset("app|foo.txt", "foo");
+      buildShouldSucceed();
+    });
+
+    test("passes an asset through when its overwriting transform is removed "
+        "during apply", () {
+      var rewrite = new RewriteTransformer("txt", "txt");
+      initGraph(["app|foo.txt"], {"app": [[rewrite]]});
+
+      rewrite.pauseApply();
+      updateSources(["app|foo.txt"]);
+      expectAssetDoesNotComplete("app|foo.txt");
+
+      updateTransformers("app", [[]]);
+      rewrite.resumeApply();
+      expectAsset("app|foo.txt", "foo");
+      buildShouldSucceed();
+    });
+
+    test("doesn't pass an asset through when its overwriting transform is "
+        "removed during apply if another transform overwrites it", () {
+      var rewrite1 = new RewriteTransformer("txt", "txt");
+      var rewrite2 = new RewriteTransformer("txt", "txt");
+      initGraph(["app|foo.txt"], {"app": [[rewrite1, rewrite2]]});
+
+      rewrite1.pauseApply();
+      updateSources(["app|foo.txt"]);
+      expectAssetDoesNotComplete("app|foo.txt");
+      // Ensure we're waiting on [rewrite1.apply]
+      schedule(pumpEventQueue);
+
+      updateTransformers("app", [[rewrite2]]);
+      rewrite1.resumeApply();
+      expectAsset("app|foo.txt", "foo.txt");
+      buildShouldSucceed();
+    });
+
+    test("doesn't pass an asset through when one overwriting transform is "
+        "removed if another transform still overwrites it", () {
+      var rewrite = new RewriteTransformer("txt", "txt");
+      initGraph(["app|foo.txt"], {"app": [[
+        rewrite,
+        new RewriteTransformer("txt", "txt")
+      ]]});
+
+      updateSources(["app|foo.txt"]);
+      // This could be either the output of [CheckContentTransformer] or
+      // [RewriteTransformer], depending which completes first.
+      expectAsset("app|foo.txt", anything);
+      buildShouldFail([isAssetCollisionException("app|foo.txt")]);
+
+      updateTransformers("app", [[rewrite]]);
+      expectAsset("app|foo.txt", "foo.txt");
+      buildShouldSucceed();
+    });
+  });
+
   // Regression test.
   test("a phase is added, then an input is removed and re-added", () {
     var rewrite = new RewriteTransformer("txt", "mid");
     initGraph(["app|foo.txt"], {
       "app": [[rewrite]]
     });
 
     updateSources(["app|foo.txt"]);
     expectAsset("app|foo.mid", "foo.mid");
     buildShouldSucceed();
 
     updateTransformers("app", [
       [rewrite],
       [new RewriteTransformer("mid", "out")]
     ]);
     expectAsset("app|foo.out", "foo.mid.out");
     buildShouldSucceed();
 
     removeSources(["app|foo.txt"]);
     expectNoAsset("app|foo.out");
     buildShouldSucceed();
 
     updateSources(["app|foo.txt"]);
     expectAsset("app|foo.out", "foo.mid.out");
     buildShouldSucceed();
   });
 }