| // 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. |
| |
| /// This library contains tests for transformer behavior that relates to actions |
| /// happening concurrently or other complex asynchronous timing behavior. |
| library barback.test.package_graph.transform.concurrency_test; |
| |
| import 'package:barback/src/utils.dart'; |
| import 'package:scheduled_test/scheduled_test.dart'; |
| |
| import '../../utils.dart'; |
| |
| main() { |
| initConfig(); |
| test("runs transforms in the same phase in parallel", () { |
| var transformerA = new RewriteTransformer("txt", "a"); |
| var transformerB = new RewriteTransformer("txt", "b"); |
| initGraph(["app|foo.txt"], {"app": [[transformerA, transformerB]]}); |
| |
| transformerA.pauseApply(); |
| transformerB.pauseApply(); |
| |
| updateSources(["app|foo.txt"]); |
| |
| transformerA.waitUntilStarted(); |
| transformerB.waitUntilStarted(); |
| |
| // They should both still be running. |
| expect(transformerA.isRunning, completion(isTrue)); |
| expect(transformerB.isRunning, completion(isTrue)); |
| |
| transformerA.resumeApply(); |
| transformerB.resumeApply(); |
| |
| expectAsset("app|foo.a", "foo.a"); |
| expectAsset("app|foo.b", "foo.b"); |
| buildShouldSucceed(); |
| }); |
| |
| test("discards outputs from a transform whose primary input is removed " |
| "during processing", () { |
| var rewrite = new RewriteTransformer("txt", "out"); |
| initGraph(["app|foo.txt"], {"app": [[rewrite]]}); |
| |
| rewrite.pauseApply(); |
| updateSources(["app|foo.txt"]); |
| rewrite.waitUntilStarted(); |
| |
| removeSources(["app|foo.txt"]); |
| rewrite.resumeApply(); |
| expectNoAsset("app|foo.out"); |
| buildShouldSucceed(); |
| }); |
| |
| test("applies the correct transform if an asset is modified during isPrimary", |
| () { |
| var check1 = new CheckContentTransformer("first", "#1"); |
| var check2 = new CheckContentTransformer("second", "#2"); |
| initGraph({ |
| "app|foo.txt": "first", |
| }, {"app": [[check1, check2]]}); |
| |
| check1.pauseIsPrimary("app|foo.txt"); |
| updateSources(["app|foo.txt"]); |
| // Ensure that we're waiting on check1's isPrimary. |
| schedule(pumpEventQueue); |
| |
| modifyAsset("app|foo.txt", "second"); |
| updateSources(["app|foo.txt"]); |
| check1.resumeIsPrimary("app|foo.txt"); |
| |
| expectAsset("app|foo.txt", "second#2"); |
| buildShouldSucceed(); |
| }); |
| |
| test("applies the correct transform if an asset is removed and added during " |
| "isPrimary", () { |
| var check1 = new CheckContentTransformer("first", "#1"); |
| var check2 = new CheckContentTransformer("second", "#2"); |
| initGraph({ |
| "app|foo.txt": "first", |
| }, {"app": [[check1, check2]]}); |
| |
| check1.pauseIsPrimary("app|foo.txt"); |
| updateSources(["app|foo.txt"]); |
| // Ensure that we're waiting on check1's isPrimary. |
| schedule(pumpEventQueue); |
| |
| removeSources(["app|foo.txt"]); |
| modifyAsset("app|foo.txt", "second"); |
| updateSources(["app|foo.txt"]); |
| check1.resumeIsPrimary("app|foo.txt"); |
| |
| expectAsset("app|foo.txt", "second#2"); |
| buildShouldSucceed(); |
| }); |
| |
| test("restarts processing if a change occurs during processing", () { |
| var transformer = new RewriteTransformer("txt", "out"); |
| initGraph(["app|foo.txt"], {"app": [[transformer]]}); |
| |
| transformer.pauseApply(); |
| |
| updateSources(["app|foo.txt"]); |
| transformer.waitUntilStarted(); |
| |
| // Now update the graph during it. |
| updateSources(["app|foo.txt"]); |
| transformer.resumeApply(); |
| |
| expectAsset("app|foo.out", "foo.out"); |
| buildShouldSucceed(); |
| |
| expect(transformer.numRuns, completion(equals(2))); |
| }); |
| |
| test("aborts processing if the primary input is removed during processing", |
| () { |
| var transformer = new RewriteTransformer("txt", "out"); |
| initGraph(["app|foo.txt"], {"app": [[transformer]]}); |
| |
| transformer.pauseApply(); |
| |
| updateSources(["app|foo.txt"]); |
| transformer.waitUntilStarted(); |
| |
| // Now remove its primary input while it's running. |
| removeSources(["app|foo.txt"]); |
| transformer.resumeApply(); |
| |
| expectNoAsset("app|foo.out"); |
| buildShouldSucceed(); |
| |
| expect(transformer.numRuns, completion(equals(1))); |
| }); |
| |
| test("restarts processing if a change to a new secondary input occurs during " |
| "processing", () { |
| var transformer = new ManyToOneTransformer("txt"); |
| initGraph({ |
| "app|foo.txt": "bar.inc", |
| "app|bar.inc": "bar" |
| }, {"app": [[transformer]]}); |
| |
| transformer.pauseApply(); |
| |
| updateSources(["app|foo.txt", "app|bar.inc"]); |
| transformer.waitUntilStarted(); |
| |
| // Give the transform time to load bar.inc the first time. |
| schedule(pumpEventQueue); |
| |
| // Now update the secondary input before the transform finishes. |
| modifyAsset("app|bar.inc", "baz"); |
| updateSources(["app|bar.inc"]); |
| // Give bar.inc enough time to be loaded and marked available before the |
| // transformer completes. |
| schedule(pumpEventQueue); |
| |
| transformer.resumeApply(); |
| |
| expectAsset("app|foo.out", "baz"); |
| buildShouldSucceed(); |
| |
| expect(transformer.numRuns, completion(equals(2))); |
| }); |
| |
| test("doesn't restart processing if a change to an old secondary input " |
| "occurs during processing", () { |
| var transformer = new ManyToOneTransformer("txt"); |
| initGraph({ |
| "app|foo.txt": "bar.inc", |
| "app|bar.inc": "bar", |
| "app|baz.inc": "baz" |
| }, {"app": [[transformer]]}); |
| |
| updateSources(["app|foo.txt", "app|bar.inc", "app|baz.inc"]); |
| expectAsset("app|foo.out", "bar"); |
| buildShouldSucceed(); |
| |
| transformer.pauseApply(); |
| modifyAsset("app|foo.txt", "baz.inc"); |
| updateSources(["app|foo.txt"]); |
| transformer.waitUntilStarted(); |
| |
| // Now update the old secondary input before the transform finishes. |
| modifyAsset("app|bar.inc", "new bar"); |
| updateSources(["app|bar.inc"]); |
| // Give bar.inc enough time to be loaded and marked available before the |
| // transformer completes. |
| schedule(pumpEventQueue); |
| |
| transformer.resumeApply(); |
| expectAsset("app|foo.out", "baz"); |
| buildShouldSucceed(); |
| |
| // Should have run once the first time, then again when switching to |
| // baz.inc. Should not run a third time because of bar.inc being modified. |
| expect(transformer.numRuns, completion(equals(2))); |
| }); |
| |
| test("restarts before finishing later phases when a change occurs", () { |
| var txtToInt = new RewriteTransformer("txt", "int"); |
| var intToOut = new RewriteTransformer("int", "out"); |
| initGraph(["app|foo.txt", "app|bar.txt"], |
| {"app": [[txtToInt], [intToOut]]}); |
| |
| txtToInt.pauseApply(); |
| |
| updateSources(["app|foo.txt"]); |
| txtToInt.waitUntilStarted(); |
| |
| // Now update the graph during it. |
| updateSources(["app|bar.txt"]); |
| txtToInt.resumeApply(); |
| |
| expectAsset("app|foo.out", "foo.int.out"); |
| expectAsset("app|bar.out", "bar.int.out"); |
| buildShouldSucceed(); |
| |
| // Should only have run each transform once for each primary. |
| expect(txtToInt.numRuns, completion(equals(2))); |
| expect(intToOut.numRuns, completion(equals(2))); |
| }); |
| |
| test("doesn't return an asset until it's finished rebuilding", () { |
| initGraph(["app|foo.in"], {"app": [ |
| [new RewriteTransformer("in", "mid")], |
| [new RewriteTransformer("mid", "out")] |
| ]}); |
| |
| updateSources(["app|foo.in"]); |
| expectAsset("app|foo.out", "foo.mid.out"); |
| buildShouldSucceed(); |
| |
| pauseProvider(); |
| modifyAsset("app|foo.in", "new"); |
| updateSources(["app|foo.in"]); |
| expectAssetDoesNotComplete("app|foo.out"); |
| buildShouldNotBeDone(); |
| |
| resumeProvider(); |
| expectAsset("app|foo.out", "new.mid.out"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't return an asset until its in-place transform is done", () { |
| var rewrite = new RewriteTransformer("txt", "txt"); |
| initGraph(["app|foo.txt"], {"app": [[rewrite]]}); |
| |
| rewrite.pauseApply(); |
| updateSources(["app|foo.txt"]); |
| expectAssetDoesNotComplete("app|foo.txt"); |
| |
| rewrite.resumeApply(); |
| expectAsset("app|foo.txt", "foo.txt"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't return an asset that's removed during isPrimary", () { |
| var rewrite = new RewriteTransformer("txt", "txt"); |
| initGraph(["app|foo.txt"], {"app": [[rewrite]]}); |
| |
| rewrite.pauseIsPrimary("app|foo.txt"); |
| updateSources(["app|foo.txt"]); |
| // Make sure we're waiting on isPrimary. |
| schedule(pumpEventQueue); |
| |
| removeSources(["app|foo.txt"]); |
| rewrite.resumeIsPrimary("app|foo.txt"); |
| expectNoAsset("app|foo.txt"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't transform an asset that goes from primary to non-primary " |
| "during isPrimary", () { |
| var check = new CheckContentTransformer(new RegExp(r"^do$"), "ne"); |
| initGraph({ |
| "app|foo.txt": "do" |
| }, {"app": [[check]]}); |
| |
| check.pauseIsPrimary("app|foo.txt"); |
| updateSources(["app|foo.txt"]); |
| // Make sure we're waiting on isPrimary. |
| schedule(pumpEventQueue); |
| |
| modifyAsset("app|foo.txt", "don't"); |
| updateSources(["app|foo.txt"]); |
| check.resumeIsPrimary("app|foo.txt"); |
| |
| expectAsset("app|foo.txt", "don't"); |
| buildShouldSucceed(); |
| }); |
| |
| test("transforms an asset that goes from non-primary to primary " |
| "during isPrimary", () { |
| var check = new CheckContentTransformer("do", "ne"); |
| initGraph({ |
| "app|foo.txt": "don't" |
| }, {"app": [[check]]}); |
| |
| check.pauseIsPrimary("app|foo.txt"); |
| updateSources(["app|foo.txt"]); |
| // Make sure we're waiting on isPrimary. |
| schedule(pumpEventQueue); |
| |
| modifyAsset("app|foo.txt", "do"); |
| updateSources(["app|foo.txt"]); |
| check.resumeIsPrimary("app|foo.txt"); |
| |
| expectAsset("app|foo.txt", "done"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't return an asset that's removed during another transformer's " |
| "isPrimary", () { |
| var rewrite1 = new RewriteTransformer("txt", "txt"); |
| var rewrite2 = new RewriteTransformer("md", "md"); |
| initGraph(["app|foo.txt", "app|foo.md"], {"app": [[rewrite1, rewrite2]]}); |
| |
| rewrite2.pauseIsPrimary("app|foo.md"); |
| updateSources(["app|foo.txt", "app|foo.md"]); |
| // Make sure we're waiting on the correct isPrimary. |
| schedule(pumpEventQueue); |
| |
| removeSources(["app|foo.txt"]); |
| rewrite2.resumeIsPrimary("app|foo.md"); |
| expectNoAsset("app|foo.txt"); |
| expectAsset("app|foo.md", "foo.md"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't transform an asset that goes from primary to non-primary " |
| "during another transformer's isPrimary", () { |
| var rewrite = new RewriteTransformer("md", "md"); |
| var check = new CheckContentTransformer(new RegExp(r"^do$"), "ne"); |
| initGraph({ |
| "app|foo.txt": "do", |
| "app|foo.md": "foo" |
| }, {"app": [[rewrite, check]]}); |
| |
| rewrite.pauseIsPrimary("app|foo.md"); |
| updateSources(["app|foo.txt", "app|foo.md"]); |
| // Make sure we're waiting on the correct isPrimary. |
| schedule(pumpEventQueue); |
| |
| modifyAsset("app|foo.txt", "don't"); |
| updateSources(["app|foo.txt"]); |
| rewrite.resumeIsPrimary("app|foo.md"); |
| |
| expectAsset("app|foo.txt", "don't"); |
| expectAsset("app|foo.md", "foo.md"); |
| buildShouldSucceed(); |
| }); |
| |
| test("transforms an asset that goes from non-primary to primary " |
| "during another transformer's isPrimary", () { |
| var rewrite = new RewriteTransformer("md", "md"); |
| var check = new CheckContentTransformer("do", "ne"); |
| initGraph({ |
| "app|foo.txt": "don't", |
| "app|foo.md": "foo" |
| }, {"app": [[rewrite, check]]}); |
| |
| rewrite.pauseIsPrimary("app|foo.md"); |
| updateSources(["app|foo.txt", "app|foo.md"]); |
| // Make sure we're waiting on the correct isPrimary. |
| schedule(pumpEventQueue); |
| |
| modifyAsset("app|foo.txt", "do"); |
| updateSources(["app|foo.txt"]); |
| rewrite.resumeIsPrimary("app|foo.md"); |
| |
| expectAsset("app|foo.txt", "done"); |
| expectAsset("app|foo.md", "foo.md"); |
| buildShouldSucceed(); |
| }); |
| |
| test("returns an asset even if an unrelated build is running", () { |
| initGraph([ |
| "app|foo.in", |
| "app|bar.in", |
| ], {"app": [[new RewriteTransformer("in", "out")]]}); |
| |
| updateSources(["app|foo.in", "app|bar.in"]); |
| expectAsset("app|foo.out", "foo.out"); |
| expectAsset("app|bar.out", "bar.out"); |
| buildShouldSucceed(); |
| |
| pauseProvider(); |
| modifyAsset("app|foo.in", "new"); |
| updateSources(["app|foo.in"]); |
| expectAssetDoesNotComplete("app|foo.out"); |
| expectAsset("app|bar.out", "bar.out"); |
| buildShouldNotBeDone(); |
| |
| resumeProvider(); |
| expectAsset("app|foo.out", "new.out"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't report AssetNotFound until all builds are finished", () { |
| initGraph([ |
| "app|foo.in", |
| ], {"app": [[new RewriteTransformer("in", "out")]]}); |
| |
| updateSources(["app|foo.in"]); |
| expectAsset("app|foo.out", "foo.out"); |
| buildShouldSucceed(); |
| |
| pauseProvider(); |
| updateSources(["app|foo.in"]); |
| expectAssetDoesNotComplete("app|foo.out"); |
| expectAssetDoesNotComplete("app|non-existent.out"); |
| buildShouldNotBeDone(); |
| |
| resumeProvider(); |
| expectAsset("app|foo.out", "foo.out"); |
| expectNoAsset("app|non-existent.out"); |
| buildShouldSucceed(); |
| }); |
| |
| test("doesn't emit a result until all builds are finished", () { |
| var rewrite = new RewriteTransformer("txt", "out"); |
| initGraph([ |
| "pkg1|foo.txt", |
| "pkg2|foo.txt" |
| ], {"pkg1": [[rewrite]], "pkg2": [[rewrite]]}); |
| |
| // First, run both packages' transformers so both packages are successful. |
| updateSources(["pkg1|foo.txt", "pkg2|foo.txt"]); |
| expectAsset("pkg1|foo.out", "foo.out"); |
| expectAsset("pkg2|foo.out", "foo.out"); |
| buildShouldSucceed(); |
| |
| // pkg1 is still successful, but pkg2 is waiting on the provider, so the |
| // overall build shouldn't finish. |
| pauseProvider(); |
| updateSources(["pkg2|foo.txt"]); |
| expectAsset("pkg1|foo.out", "foo.out"); |
| buildShouldNotBeDone(); |
| |
| // Now that the provider is unpaused, pkg2's transforms finish and the |
| // overall build succeeds. |
| resumeProvider(); |
| buildShouldSucceed(); |
| }); |
| |
| test("one transformer takes a long time while the other finishes, then " |
| "the input is removed", () { |
| var rewrite1 = new RewriteTransformer("txt", "out1"); |
| var rewrite2 = new RewriteTransformer("txt", "out2"); |
| initGraph(["app|foo.txt"], {"app": [[rewrite1, rewrite2]]}); |
| |
| rewrite1.pauseApply(); |
| |
| updateSources(["app|foo.txt"]); |
| |
| // Wait for rewrite1 to pause and rewrite2 to finish. |
| schedule(pumpEventQueue); |
| |
| removeSources(["app|foo.txt"]); |
| |
| // Make sure the removal is processed completely before we restart rewrite2. |
| schedule(pumpEventQueue); |
| rewrite1.resumeApply(); |
| |
| buildShouldSucceed(); |
| expectNoAsset("app|foo.out1"); |
| expectNoAsset("app|foo.out2"); |
| }); |
| |
| test("a transformer in a later phase gets a slow secondary input from an " |
| "earlier phase", () { |
| var rewrite = new RewriteTransformer("in", "in"); |
| initGraph({ |
| "app|foo.in": "foo", |
| "app|bar.txt": "foo.in" |
| }, {"app": [ |
| [rewrite], |
| [new ManyToOneTransformer("txt")] |
| ]}); |
| |
| rewrite.pauseApply(); |
| updateSources(["app|foo.in", "app|bar.txt"]); |
| expectAssetDoesNotComplete("app|bar.out"); |
| |
| rewrite.resumeApply(); |
| expectAsset("app|bar.out", "foo.in"); |
| buildShouldSucceed(); |
| }); |
| |
| test("materializes a passed-through asset that was emitted before it was " |
| "available", () { |
| initGraph(["app|foo.in"], {"app": [ |
| [new RewriteTransformer("txt", "txt")] |
| ]}); |
| |
| pauseProvider(); |
| updateSources(["app|foo.in"]); |
| expectAssetDoesNotComplete("app|foo.in"); |
| |
| resumeProvider(); |
| expectAsset("app|foo.in", "foo"); |
| buildShouldSucceed(); |
| }); |
| |
| test("re-runs if the primary input is invalidated before accessing", () { |
| var transformer1 = new RewriteTransformer("txt", "mid"); |
| var transformer2 = new RewriteTransformer("mid", "out"); |
| |
| initGraph([ |
| "app|foo.txt" |
| ], {"app": [ |
| [transformer1], |
| [transformer2] |
| ]}); |
| |
| transformer2.pausePrimaryInput(); |
| updateSources(["app|foo.txt"]); |
| |
| // Wait long enough to ensure that transformer1 has completed and |
| // transformer2 has started. |
| schedule(pumpEventQueue); |
| |
| // Update the source again so that transformer1 invalidates the primary |
| // input of transformer2. |
| transformer1.pauseApply(); |
| modifyAsset("app|foo.txt", "new foo"); |
| updateSources(["app|foo.txt"]); |
| |
| transformer2.resumePrimaryInput(); |
| transformer1.resumeApply(); |
| |
| expectAsset("app|foo.out", "new foo.mid.out"); |
| buildShouldSucceed(); |
| |
| expect(transformer1.numRuns, completion(equals(2))); |
| expect(transformer2.numRuns, completion(equals(2))); |
| }); |
| } |