Roll Observatory packages and add a roll script

packages/barback/test/package_graph/declaring_transformer_test.dart

Index: packages/barback/test/package_graph/declaring_transformer_test.dart
diff --git a/packages/barback/test/package_graph/declaring_transformer_test.dart b/packages/barback/test/package_graph/declaring_transformer_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..aa830dfde0bd555064805def4d46a706d200003f
--- /dev/null
+++ b/packages/barback/test/package_graph/declaring_transformer_test.dart
@@ -0,0 +1,371 @@
+// Copyright (c) 2014, 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.declaring_transformer_test;
+
+import 'package:barback/barback.dart';
+import 'package:barback/src/utils.dart';
+import 'package:scheduled_test/scheduled_test.dart';
+
+import '../utils.dart';
+
+main() {
+  initConfig();
+
+  test("gets a declared output with a different path", () {
+    initGraph(["app|foo.blub"], {"app": [
+      [new DeclaringRewriteTransformer("blub", "blab")]
+    ]});
+    updateSources(["app|foo.blub"]);
+    expectAsset("app|foo.blab", "foo.blab");
+    buildShouldSucceed();
+  });
+
+  test("gets a declared output with the same path", () {
+    initGraph(["app|foo.blub"], {"app": [
+      [new DeclaringRewriteTransformer("blub", "blub")]
+    ]});
+    updateSources(["app|foo.blub"]);
+    expectAsset("app|foo.blub", "foo.blub");
+    buildShouldSucceed();
+  });
+
+  test("gets a passed-through asset", () {
+    initGraph(["app|foo.blub"], {"app": [
+      [new DeclaringRewriteTransformer("blub", "blab")]
+    ]});
+    updateSources(["app|foo.blub"]);
+    expectAsset("app|foo.blub", "foo");
+    buildShouldSucceed();
+  });
+
+  test("doesn't get a consumed asset", () {
+    initGraph(["app|foo.blub"], {"app": [
+      [new DeclaringRewriteTransformer("blub", "blab")..consumePrimary = true]
+    ]});
+    updateSources(["app|foo.blub"]);
+    expectNoAsset("app|foo.blub");
+    buildShouldSucceed();
+  });
+
+  test("gets a passed-through asset before apply is finished", () {
+    var transformer = new DeclaringRewriteTransformer("blub", "blab");
+    initGraph(["app|foo.blub"], {"app": [[transformer]]});
+
+    transformer.pauseApply();
+    updateSources(["app|foo.blub"]);
+    expectAsset("app|foo.blub", "foo");
+
+    transformer.resumeApply();
+    buildShouldSucceed();
+  });
+
+  test("fails to get a consumed asset before apply is finished", () {
+    var transformer = new DeclaringRewriteTransformer("blub", "blab")
+        ..consumePrimary = true;
+    initGraph(["app|foo.blub"], {"app": [[transformer]]});
+  
+    transformer.pauseApply();
+    updateSources(["app|foo.blub"]);
+    expectNoAsset("app|foo.blub");
+  
+    transformer.resumeApply();
+    buildShouldSucceed();
+  });
+
+  test("blocks on getting a declared asset that wasn't generated last run", () {
+    var transformer = new DeclaringCheckContentAndRenameTransformer(
+          oldExtension: "txt", oldContent: "yes",
+          newExtension: "out", newContent: "done");
+    initGraph({"app|foo.txt": "no"}, {"app": [[transformer]]});
+
+    updateSources(["app|foo.txt"]);
+    expectNoAsset("app|foo.out");
+    buildShouldSucceed();
+
+    // The transform should remember that foo.out was declared, so it should
+    // expect that it might still be generated even though it wasn't last time.
+    transformer.pauseApply();
+    modifyAsset("app|foo.txt", "yes");
+    updateSources(["app|foo.txt"]);
+    expectAssetDoesNotComplete("app|foo.out");
+
+    transformer.resumeApply();
+    expectAsset("app|foo.out", "done");
+    buildShouldSucceed();
+  });
+
+  test("doesn't block on on getting an undeclared asset that wasn't generated "
+      "last run", () {
+    var transformer = new DeclaringCheckContentAndRenameTransformer(
+          oldExtension: "txt", oldContent: "yes",
+          newExtension: "out", newContent: "done");
+    initGraph({"app|foo.txt": "no"}, {"app": [[transformer]]});
+
+    updateSources(["app|foo.txt"]);
+    expectNoAsset("app|foo.out");
+    buildShouldSucceed();
+
+    transformer.pauseApply();
+    modifyAsset("app|foo.txt", "yes");
+    updateSources(["app|foo.txt"]);
+    expectNoAsset("app|undeclared.out");
+
+    transformer.resumeApply();
+    buildShouldSucceed();
+  });
+
+  test("fails to get a consumed asset before apply is finished when a sibling "
+      "has finished applying", () {
+    var transformer = new DeclaringRewriteTransformer("blub", "blab")
+        ..consumePrimary = true;
+    initGraph(["app|foo.blub", "app|foo.txt"], {"app": [[
+      transformer,
+      new RewriteTransformer("txt", "out")
+    ]]});
+  
+    transformer.pauseApply();
+    updateSources(["app|foo.blub", "app|foo.txt"]);
+    expectAsset("app|foo.out", "foo.out");
+    expectNoAsset("app|foo.blub");
+  
+    transformer.resumeApply();
+    buildShouldSucceed();
+  });
+
+  test("blocks getting a consumed asset before apply is finished when a "
+      "sibling hasn't finished applying", () {
+    var declaring = new DeclaringRewriteTransformer("blub", "blab")
+        ..consumePrimary = true;
+    var eager = new RewriteTransformer("txt", "out");
+    initGraph(["app|foo.blub", "app|foo.txt"], {"app": [[declaring, eager]]});
+  
+    declaring.pauseApply();
+    eager.pauseApply();
+    updateSources(["app|foo.blub", "app|foo.txt"]);
+    expectAssetDoesNotComplete("app|foo.blub");
+  
+    declaring.resumeApply();
+    eager.resumeApply();
+    expectNoAsset("app|foo.blub");
+    buildShouldSucceed();
+  });
+
+  test("waits until apply is finished to get an overwritten asset", () {
+    var transformer = new DeclaringRewriteTransformer("blub", "blub");
+    initGraph(["app|foo.blub"], {"app": [[transformer]]});
+
+    transformer.pauseApply();
+    updateSources(["app|foo.blub"]);
+    expectAssetDoesNotComplete("app|foo.blub");
+
+    transformer.resumeApply();
+    expectAsset("app|foo.blub", "foo.blub");
+    buildShouldSucceed();
+  });
+
+  // Regression test for #64.
+  test("a declaring transformer's output passes through a lazy transformer",
+      () {
+    var declaring = new DeclaringRewriteTransformer("one", "two");
+    initGraph(["app|foo.one"], {"app": [
+      [declaring],
+      [new LazyRewriteTransformer("two", "three")]
+    ]});
+
+    updateSources(["app|foo.one"]);
+    // Give the transformers time to declare their assets.
+    schedule(pumpEventQueue);
+
+    expectAsset("app|foo.one", "foo");
+    expectAsset("app|foo.two", "foo.two");
+    expectAsset("app|foo.three", "foo.two.three");
+    buildShouldSucceed();
+
+    modifyAsset("app|foo.one", "bar");
+    updateSources(["app|foo.one"]);
+
+    expectAsset("app|foo.one", "bar");
+    expectAsset("app|foo.two", "bar.two");
+    expectAsset("app|foo.three", "bar.two.three");
+    buildShouldSucceed();
+
+    expect(declaring.numRuns, completion(equals(2)));
+  });
+
+  test("a declaring transformer following a lazy transformer runs eagerly once "
+      "its input is available", () {
+    var declaring = new DeclaringRewriteTransformer("two", "three");
+    initGraph(["app|foo.in"], {"app": [
+      [new LazyAssetsTransformer(["app|out.one", "app|out.two"])],
+      [declaring]
+    ]});
+
+    updateSources(["app|foo.in"]);
+    // Give the transformers time to declare their assets.
+    schedule(pumpEventQueue);
+
+    expectAsset("app|out.one", "app|out.one");
+    buildShouldSucceed();
+
+    expect(declaring.numRuns, completion(equals(1)));
+  });
+
+  test("a declaring transformer following a lazy transformer doesn't re-run if "
+      "its input becomes available and then unavailable", () {
+    var declaring = new DeclaringRewriteTransformer("two", "three");
+    initGraph(["app|foo.in"], {"app": [
+      [new LazyAssetsTransformer(["app|out.one", "app|out.two"])],
+      [declaring]
+    ]});
+
+    declaring.pauseApply();
+    updateSources(["app|foo.in"]);
+    // Give the transformers time to declare their assets.
+    schedule(pumpEventQueue);
+
+    // Start [declaring] running, because its input became available.
+    expectAsset("app|out.one", "app|out.one");
+
+    // Make sure we're blocking on [declaring.apply].
+    schedule(pumpEventQueue);
+
+    // Now [declaring]'s input is dirty, so it shouldn't re-run without an
+    // explicit request.
+    updateSources(["app|foo.in"]);
+    declaring.resumeApply();
+    buildShouldSucceed();
+
+    // [declaring] should only have run once, despite its input changing. After
+    // the first run, it should be awaiting a force() call.
+    expect(declaring.numRuns, completion(equals(1)));
+
+    // Once we make a request, [declaring] should force the lazy transformer and
+    // then run itself.
+    expectAsset("app|out.three", "app|out.two.three");
+    buildShouldSucceed();
+
+    // Now [declaring] should have run twice. This ensures that it didn't use
+    // its original output for some reason.
+    expect(declaring.numRuns, completion(equals(2)));
+  });
+
+  test("a declaring transformer following a lazy transformer does re-run if "
+      "its input becomes available, it's forced, and then its input becomes "
+      "unavailable", () {
+    var declaring = new DeclaringRewriteTransformer("two", "three");
+    initGraph(["app|foo.in"], {"app": [
+      [new LazyAssetsTransformer(["app|out.one", "app|out.two"])],
+      [declaring]
+    ]});
+
+    declaring.pauseApply();
+    updateSources(["app|foo.in"]);
+
+    // Give the transformers time to declare their assets.
+    schedule(pumpEventQueue);
+
+    // Start [declaring] running, because its input became available.
+    expectAsset("app|out.one", "app|out.one");
+
+    // This shouldn't complete because [declaring.apply] is paused, but it
+    // should force the transformer.
+    expectAssetDoesNotComplete("app|out.three");
+
+    // Make sure we're blocking on [declaring.apply]
+    schedule(pumpEventQueue);
+
+    // Now [declaring]'s input is dirty, so it shouldn't re-run without an
+    // explicit request.
+    updateSources(["app|foo.in"]);
+    declaring.resumeApply();
+    buildShouldSucceed();
+
+    // [declaring] should have run twice, once for its original input and once
+    // after the input changed because it was forced.
+    expect(declaring.numRuns, completion(equals(2)));
+  });
+
+  group("with an error in declareOutputs", () {
+    test("still runs apply", () {
+      initGraph(["app|foo.txt"], {"app": [[
+        new DeclaringBadTransformer("app|out.txt",
+            declareError: true, applyError: false)
+      ]]});
+
+      updateSources(["app|foo.txt"]);
+      expectAsset("app|out.txt", "bad out");
+      expectAsset("app|foo.txt", "foo");
+      buildShouldFail([isTransformerException(BadTransformer.ERROR)]);
+    });
+
+    test("waits for apply to complete before passing through the input even if "
+        "consumePrimary was called", () {
+      var transformer = new DeclaringBadTransformer("app|out.txt",
+            declareError: true, applyError: false)..consumePrimary = true;
+      initGraph(["app|foo.txt"], {"app": [[transformer]]});
+
+      transformer.pauseApply();
+      updateSources(["app|foo.txt"]);
+      expectAssetDoesNotComplete("app|out.txt");
+      expectAssetDoesNotComplete("app|foo.txt");
+
+      transformer.resumeApply();
+      expectAsset("app|out.txt", "bad out");
+      expectNoAsset("app|foo.txt");
+      buildShouldFail([isTransformerException(BadTransformer.ERROR)]);
+    });
+  });
+
+  test("with an error in apply still passes through the input", () {
+   initGraph(["app|foo.txt"], {"app": [[
+     new DeclaringBadTransformer("app|out.txt",
+         declareError: false, applyError: true)
+   ]]});
+
+   updateSources(["app|foo.txt"]);
+   expectNoAsset("app|out.txt");
+   expectAsset("app|foo.txt", "foo");
+   buildShouldFail([isTransformerException(BadTransformer.ERROR)]);
+  });
+
+  test("can emit outputs it didn't declare", () {
+    initGraph(["app|foo.txt"], {"app": [
+      [new DeclareAssetsTransformer([], emitted: ["app|out.txt"])]
+    ]});
+
+    updateSources(["app|foo.txt"]);
+    // There's probably going to be some time when "out.txt" is unavailable,
+    // since it was undeclared.
+    schedule(pumpEventQueue);
+    expectAsset("app|out.txt", "app|out.txt");
+    buildShouldSucceed();
+  });
+
+  test("can overwrite the primary input even if it declared that it wouldn't",
+      () {
+    var transformer = new DeclareAssetsTransformer(
+        [], emitted: ["app|foo.txt"]);
+    initGraph(["app|foo.txt"], {"app": [[transformer]]});
+
+    transformer.pauseApply();
+    updateSources(["app|foo.txt"]);
+    expectAsset("app|foo.txt", "foo");
+
+    transformer.resumeApply();
+    schedule(pumpEventQueue);
+    expectAsset("app|foo.txt", "app|foo.txt");
+    buildShouldSucceed();
+  });
+
+  test("can declare outputs it doesn't emit", () {
+    initGraph(["app|foo.txt"], {"app": [
+      [new DeclareAssetsTransformer(["app|out.txt"], emitted: [])]
+    ]});
+
+    updateSources(["app|foo.txt"]);
+    expectNoAsset("app|out.txt");
+    buildShouldSucceed();
+  });
+}