Revert commits r33138, r33135, and r33134.

pkg/barback/test/package_graph/group_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.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": [
@@ skipping 30 matching lines @@
 
   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)));
@@ skipping 54 matching lines @@
         ])]
       ]});
       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();
     });
 
-    // TODO(nweiz): re-enable this test when a transformer can consume its
-    // primary input (issue 16612).
-    // 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();
-    // });
+    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 non-overwritten inputs through a group", () {
-      initGraph(["app|foo.a"], {"app": [
-        [new TransformerGroup([
-          [new RewriteTransformer("a", "b")],
-          [new RewriteTransformer("b", "c")]
-        ])]
-      ]});
-      updateSources(["app|foo.a"]);
-      expectAsset("app|foo.a", "foo");
-      expectAsset("app|foo.b", "foo.b");
-      expectAsset("app|foo.c", "foo.b.c");
-      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")]
         ])]
       ]});
@@ skipping 12 matching lines @@
         ]),
         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 overwritten by a group but not "
-        "by transformers", () {
+    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", "a")],
+          [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.a", "foo.a");
+      expectAsset("app|foo.c", "foo.b.c");
       buildShouldSucceed();
     });
 
-    test("doesn't pass through an input that's overwritten by transformers but "
-        "not by a group", () {
+    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", "x")
+        new RewriteTransformer("x", "y")
       ]]});
       updateSources(["app|foo.x"]);
+      expectNoAsset("app|foo.x");
       expectNoAsset("app|foo.c");
-      expectAsset("app|foo.x", "foo.x");
+      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();
 
@@ skipping 23 matching lines @@
       [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 overwritten by an added group",
-      () {
+  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", "a")]])]
+      [rewrite, new TransformerGroup([
+        [new RewriteTransformer("a", "b")],
+        [new RewriteTransformer("b", "c")]
+      ])]
     ]);
-    expectAsset("app|foo.a", "foo.a");
+    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")]);
   });
 }