| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 library barback.test.package_graph.transform_test; | |
| 6 | |
| 7 import 'package:barback/src/utils.dart'; | |
| 8 import 'package:scheduled_test/scheduled_test.dart'; | |
| 9 | |
| 10 import '../utils.dart'; | |
| 11 | |
| 12 main() { | |
| 13 initConfig(); | |
| 14 test("a new transformer is applied to a matching asset", () { | |
| 15 initGraph(["app|foo.blub"]); | |
| 16 | |
| 17 updateSources(["app|foo.blub"]); | |
| 18 expectAsset("app|foo.blub", "foo"); | |
| 19 buildShouldSucceed(); | |
| 20 | |
| 21 updateTransformers("app", [[new RewriteTransformer("blub", "blab")]]); | |
| 22 expectAsset("app|foo.blab", "foo.blab"); | |
| 23 buildShouldSucceed(); | |
| 24 }); | |
| 25 | |
| 26 test("a new transformer is not applied to a non-matching asset", () { | |
| 27 initGraph(["app|foo.blub"]); | |
| 28 | |
| 29 updateSources(["app|foo.blub"]); | |
| 30 expectAsset("app|foo.blub", "foo"); | |
| 31 buildShouldSucceed(); | |
| 32 | |
| 33 updateTransformers("app", [[new RewriteTransformer("zip", "zap")]]); | |
| 34 expectAsset("app|foo.blub", "foo"); | |
| 35 expectNoAsset("app|foo.zap"); | |
| 36 buildShouldSucceed(); | |
| 37 }); | |
| 38 | |
| 39 test("updateTransformers doesn't re-run an old transformer", () { | |
| 40 var rewrite = new RewriteTransformer("blub", "blab"); | |
| 41 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | |
| 42 | |
| 43 updateSources(["app|foo.blub"]); | |
| 44 expectAsset("app|foo.blab", "foo.blab"); | |
| 45 buildShouldSucceed(); | |
| 46 | |
| 47 updateTransformers("app", [[rewrite]]); | |
| 48 expectAsset("app|foo.blab", "foo.blab"); | |
| 49 buildShouldSucceed(); | |
| 50 | |
| 51 expect(rewrite.numRuns, completion(equals(1))); | |
| 52 }); | |
| 53 | |
| 54 test("updateTransformers re-runs old transformers in a new phase", () { | |
| 55 var rewrite1 = new RewriteTransformer("txt", "blub"); | |
| 56 var rewrite2 = new RewriteTransformer("blub", "blab"); | |
| 57 initGraph(["app|foo.txt"], {"app": [[rewrite1], [rewrite2]]}); | |
| 58 | |
| 59 updateSources(["app|foo.txt"]); | |
| 60 expectAsset("app|foo.blab", "foo.blub.blab"); | |
| 61 buildShouldSucceed(); | |
| 62 | |
| 63 updateTransformers("app", [[rewrite2], [rewrite1]]); | |
| 64 expectAsset("app|foo.blub", "foo.blub"); | |
| 65 expectNoAsset("app|foo.blab"); | |
| 66 buildShouldSucceed(); | |
| 67 }); | |
| 68 | |
| 69 test("updateTransformers re-runs an old transformer when a previous phase " | |
| 70 "changes", () { | |
| 71 var rewrite = new RewriteTransformer("txt", "out"); | |
| 72 initGraph(["app|foo.txt"], {"app": [[], [rewrite]]}); | |
| 73 | |
| 74 updateSources(["app|foo.txt"]); | |
| 75 expectAsset("app|foo.out", "foo.out"); | |
| 76 buildShouldSucceed(); | |
| 77 | |
| 78 updateTransformers("app", [ | |
| 79 [new RewriteTransformer("txt", "txt")], | |
| 80 [rewrite] | |
| 81 ]); | |
| 82 expectAsset("app|foo.out", "foo.txt.out"); | |
| 83 buildShouldSucceed(); | |
| 84 }); | |
| 85 | |
| 86 test("a removed transformer is no longer applied", () { | |
| 87 initGraph(["app|foo.blub"], {"app": [ | |
| 88 [new RewriteTransformer("blub", "blab")] | |
| 89 ]}); | |
| 90 | |
| 91 updateSources(["app|foo.blub"]); | |
| 92 expectAsset("app|foo.blab", "foo.blab"); | |
| 93 buildShouldSucceed(); | |
| 94 | |
| 95 updateTransformers("app", []); | |
| 96 expectAsset("app|foo.blub", "foo"); | |
| 97 expectNoAsset("app|foo.blab"); | |
| 98 buildShouldSucceed(); | |
| 99 }); | |
| 100 | |
| 101 test("a new transformer is pipelined", () { | |
| 102 var rewrite1 = new RewriteTransformer("source", "phase1"); | |
| 103 var rewrite3 = new RewriteTransformer("phase2", "phase3"); | |
| 104 initGraph(["app|foo.source"], {"app": [ | |
| 105 [rewrite1], | |
| 106 [rewrite3] | |
| 107 ]}); | |
| 108 | |
| 109 updateSources(["app|foo.source"]); | |
| 110 expectNoAsset("app|foo.phase3"); | |
| 111 buildShouldSucceed(); | |
| 112 | |
| 113 updateTransformers("app", [ | |
| 114 [rewrite1], | |
| 115 [new RewriteTransformer("phase1", "phase2")], | |
| 116 [rewrite3] | |
| 117 ]); | |
| 118 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); | |
| 119 buildShouldSucceed(); | |
| 120 }); | |
| 121 | |
| 122 test("a removed transformer is un-pipelined", () { | |
| 123 var rewrite1 = new RewriteTransformer("source", "phase1"); | |
| 124 var rewrite3 = new RewriteTransformer("phase2", "phase3"); | |
| 125 initGraph(["app|foo.source"], {"app": [ | |
| 126 [rewrite1], | |
| 127 [new RewriteTransformer("phase1", "phase2")], | |
| 128 [rewrite3] | |
| 129 ]}); | |
| 130 | |
| 131 updateSources(["app|foo.source"]); | |
| 132 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); | |
| 133 buildShouldSucceed(); | |
| 134 | |
| 135 updateTransformers("app", [[rewrite1], [rewrite3]]); | |
| 136 expectNoAsset("app|foo.phase3"); | |
| 137 buildShouldSucceed(); | |
| 138 }); | |
| 139 | |
| 140 test("a transformer is removed during isPrimary", () { | |
| 141 var rewrite = new RewriteTransformer("blub", "blab"); | |
| 142 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | |
| 143 | |
| 144 rewrite.pauseIsPrimary("app|foo.blub"); | |
| 145 updateSources(["app|foo.blub"]); | |
| 146 // Ensure we're waiting on [rewrite.isPrimary]. | |
| 147 schedule(pumpEventQueue); | |
| 148 | |
| 149 updateTransformers("app", []); | |
| 150 rewrite.resumeIsPrimary("app|foo.blub"); | |
| 151 expectAsset("app|foo.blub", "foo"); | |
| 152 expectNoAsset("app|foo.blab"); | |
| 153 buildShouldSucceed(); | |
| 154 }); | |
| 155 | |
| 156 test("a transformer is removed during apply", () { | |
| 157 var rewrite = new RewriteTransformer("blub", "blab"); | |
| 158 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | |
| 159 | |
| 160 rewrite.pauseApply(); | |
| 161 updateSources(["app|foo.blub"]); | |
| 162 // Ensure we're waiting on [rewrite.apply]. | |
| 163 schedule(pumpEventQueue); | |
| 164 | |
| 165 updateTransformers("app", []); | |
| 166 rewrite.resumeApply(); | |
| 167 expectAsset("app|foo.blub", "foo"); | |
| 168 expectNoAsset("app|foo.blab"); | |
| 169 buildShouldSucceed(); | |
| 170 }); | |
| 171 | |
| 172 test("a transformer is added to an existing phase during isPrimary", () { | |
| 173 var rewrite = new RewriteTransformer("blub", "blab"); | |
| 174 initGraph(["app|foo.blub", "app|bar.blib"], {"app": [[rewrite]]}); | |
| 175 | |
| 176 rewrite.pauseIsPrimary("app|foo.blub"); | |
| 177 updateSources(["app|foo.blub", "app|bar.blib"]); | |
| 178 // Ensure we're waiting on [rewrite.isPrimary]. | |
| 179 schedule(pumpEventQueue); | |
| 180 | |
| 181 updateTransformers("app", [ | |
| 182 [rewrite, new RewriteTransformer("blib", "blob")] | |
| 183 ]); | |
| 184 rewrite.resumeIsPrimary("app|foo.blub"); | |
| 185 expectAsset("app|foo.blab", "foo.blab"); | |
| 186 expectAsset("app|bar.blob", "bar.blob"); | |
| 187 buildShouldSucceed(); | |
| 188 }); | |
| 189 | |
| 190 test("a cross-package transform sees a new transformer in a new phase", () { | |
| 191 var rewrite = new RewriteTransformer("inc", "inc"); | |
| 192 initGraph({ | |
| 193 "pkg1|foo.txt": "pkg2|foo.inc", | |
| 194 "pkg2|foo.inc": "foo" | |
| 195 }, { | |
| 196 "pkg1": [[new ManyToOneTransformer("txt")]], | |
| 197 "pkg2": [[rewrite]] | |
| 198 }); | |
| 199 | |
| 200 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); | |
| 201 expectAsset("pkg1|foo.out", "foo.inc"); | |
| 202 buildShouldSucceed(); | |
| 203 | |
| 204 updateTransformers("pkg2", [ | |
| 205 [rewrite], | |
| 206 [new RewriteTransformer("inc", "inc")] | |
| 207 ]); | |
| 208 expectAsset("pkg1|foo.out", "foo.inc.inc"); | |
| 209 buildShouldSucceed(); | |
| 210 }); | |
| 211 | |
| 212 test("a cross-package transform doesn't see a removed transformer in a " | |
| 213 "removed phase", () { | |
| 214 var rewrite = new RewriteTransformer("inc", "inc"); | |
| 215 initGraph({ | |
| 216 "pkg1|foo.txt": "pkg2|foo.inc", | |
| 217 "pkg2|foo.inc": "foo" | |
| 218 }, { | |
| 219 "pkg1": [[new ManyToOneTransformer("txt")]], | |
| 220 "pkg2": [ | |
| 221 [rewrite], | |
| 222 [new RewriteTransformer("inc", "inc")] | |
| 223 ] | |
| 224 }); | |
| 225 | |
| 226 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); | |
| 227 expectAsset("pkg1|foo.out", "foo.inc.inc"); | |
| 228 buildShouldSucceed(); | |
| 229 | |
| 230 updateTransformers("pkg2", [[rewrite]]); | |
| 231 expectAsset("pkg1|foo.out", "foo.inc"); | |
| 232 buildShouldSucceed(); | |
| 233 }); | |
| 234 | |
| 235 group("pass-through", () { | |
| 236 test("a new transformer can see pass-through assets", () { | |
| 237 var rewrite = new RewriteTransformer("zip", "zap"); | |
| 238 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | |
| 239 | |
| 240 updateSources(["app|foo.blub"]); | |
| 241 buildShouldSucceed(); | |
| 242 | |
| 243 updateTransformers("app", [ | |
| 244 [rewrite], | |
| 245 [new RewriteTransformer("blub", "blab")] | |
| 246 ]); | |
| 247 expectAsset("app|foo.blab", "foo.blab"); | |
| 248 buildShouldSucceed(); | |
| 249 }); | |
| 250 | |
| 251 test("a new transformer can overwrite an old asset", () { | |
| 252 var rewrite = new RewriteTransformer("zip", "zap"); | |
| 253 initGraph(["app|foo.txt"], {"app": [[rewrite]]}); | |
| 254 | |
| 255 updateSources(["app|foo.txt"]); | |
| 256 expectAsset("app|foo.txt", "foo"); | |
| 257 buildShouldSucceed(); | |
| 258 | |
| 259 // Add a transformer that will overwrite the previously-passed-through | |
| 260 // "foo.txt" asset. The transformed asset should be emitted, not the | |
| 261 // passed-through asset. | |
| 262 updateTransformers("app", [ | |
| 263 [rewrite, new RewriteTransformer("txt", "txt")] | |
| 264 ]); | |
| 265 expectAsset("app|foo.txt", "foo.txt"); | |
| 266 buildShouldSucceed(); | |
| 267 }); | |
| 268 | |
| 269 test("passes an asset through when an overwriting transform is removed", | |
| 270 () { | |
| 271 initGraph(["app|foo.txt"], { | |
| 272 "app": [[new RewriteTransformer("txt", "txt")]] | |
| 273 }); | |
| 274 | |
| 275 updateSources(["app|foo.txt"]); | |
| 276 expectAsset("app|foo.txt", "foo.txt"); | |
| 277 buildShouldSucceed(); | |
| 278 | |
| 279 updateTransformers("app", [[]]); | |
| 280 expectAsset("app|foo.txt", "foo"); | |
| 281 buildShouldSucceed(); | |
| 282 }); | |
| 283 | |
| 284 test("passes an asset through when its overwriting transform is removed " | |
| 285 "during apply", () { | |
| 286 var rewrite = new RewriteTransformer("txt", "txt"); | |
| 287 initGraph(["app|foo.txt"], {"app": [[rewrite]]}); | |
| 288 | |
| 289 rewrite.pauseApply(); | |
| 290 updateSources(["app|foo.txt"]); | |
| 291 expectAssetDoesNotComplete("app|foo.txt"); | |
| 292 | |
| 293 updateTransformers("app", [[]]); | |
| 294 rewrite.resumeApply(); | |
| 295 expectAsset("app|foo.txt", "foo"); | |
| 296 buildShouldSucceed(); | |
| 297 }); | |
| 298 | |
| 299 test("doesn't pass an asset through when its overwriting transform is " | |
| 300 "removed during apply if another transform overwrites it", () { | |
| 301 var rewrite1 = new RewriteTransformer("txt", "txt"); | |
| 302 var rewrite2 = new RewriteTransformer("txt", "txt"); | |
| 303 initGraph(["app|foo.txt"], {"app": [[rewrite1, rewrite2]]}); | |
| 304 | |
| 305 rewrite1.pauseApply(); | |
| 306 updateSources(["app|foo.txt"]); | |
| 307 expectAsset("app|foo.txt", "foo.txt"); | |
| 308 // Ensure we're waiting on [rewrite1.apply] | |
| 309 schedule(pumpEventQueue); | |
| 310 | |
| 311 updateTransformers("app", [[rewrite2]]); | |
| 312 rewrite1.resumeApply(); | |
| 313 expectAsset("app|foo.txt", "foo.txt"); | |
| 314 buildShouldSucceed(); | |
| 315 }); | |
| 316 | |
| 317 test("doesn't pass an asset through when one overwriting transform is " | |
| 318 "removed if another transform still overwrites it", () { | |
| 319 var rewrite = new RewriteTransformer("txt", "txt"); | |
| 320 initGraph(["app|foo.txt"], {"app": [[ | |
| 321 rewrite, | |
| 322 new RewriteTransformer("txt", "txt") | |
| 323 ]]}); | |
| 324 | |
| 325 updateSources(["app|foo.txt"]); | |
| 326 // This could be either the output of [CheckContentTransformer] or | |
| 327 // [RewriteTransformer], depending which completes first. | |
| 328 expectAsset("app|foo.txt", anything); | |
| 329 buildShouldFail([isAssetCollisionException("app|foo.txt")]); | |
| 330 | |
| 331 updateTransformers("app", [[rewrite]]); | |
| 332 expectAsset("app|foo.txt", "foo.txt"); | |
| 333 buildShouldSucceed(); | |
| 334 }); | |
| 335 }); | |
| 336 | |
| 337 // Regression test. | |
| 338 test("a phase is added, then an input is removed and re-added", () { | |
| 339 var rewrite = new RewriteTransformer("txt", "mid"); | |
| 340 initGraph(["app|foo.txt"], { | |
| 341 "app": [[rewrite]] | |
| 342 }); | |
| 343 | |
| 344 updateSources(["app|foo.txt"]); | |
| 345 expectAsset("app|foo.mid", "foo.mid"); | |
| 346 buildShouldSucceed(); | |
| 347 | |
| 348 updateTransformers("app", [ | |
| 349 [rewrite], | |
| 350 [new RewriteTransformer("mid", "out")] | |
| 351 ]); | |
| 352 expectAsset("app|foo.out", "foo.mid.out"); | |
| 353 buildShouldSucceed(); | |
| 354 | |
| 355 removeSources(["app|foo.txt"]); | |
| 356 expectNoAsset("app|foo.out"); | |
| 357 buildShouldSucceed(); | |
| 358 | |
| 359 updateSources(["app|foo.txt"]); | |
| 360 expectAsset("app|foo.out", "foo.mid.out"); | |
| 361 buildShouldSucceed(); | |
| 362 }); | |
| 363 | |
| 364 // Regression test for issue 19540. | |
| 365 test("a phase is removed and then one of its inputs is updated", () { | |
| 366 // Have an empty first phase because the first phase is never removed. | |
| 367 initGraph(["app|foo.txt"], { | |
| 368 "app": [[], [new RewriteTransformer("txt", "out")]] | |
| 369 }); | |
| 370 | |
| 371 updateSources(["app|foo.txt"]); | |
| 372 expectAsset("app|foo.out", "foo.out"); | |
| 373 buildShouldSucceed(); | |
| 374 | |
| 375 // First empty both phases. This allows the second phase to be considered | |
| 376 // idle even when its transformer is no longer running. | |
| 377 updateTransformers("app", [[], []]); | |
| 378 buildShouldSucceed(); | |
| 379 | |
| 380 // Now remove the second phase. It should unsubscribe from its input's | |
| 381 // events. | |
| 382 updateTransformers("app", [[]]); | |
| 383 buildShouldSucceed(); | |
| 384 | |
| 385 // Update the input. With issue 19540, this would cause the removed phase to | |
| 386 // try to update its status, which would crash. | |
| 387 updateSources(["app|foo.txt"]); | |
| 388 buildShouldSucceed(); | |
| 389 }); | |
| 390 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 808713003:
Remove barback from the repo. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart