| 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.group_test; | |
| 6 | |
| 7 import 'dart:async'; | |
| 8 | |
| 9 import 'package:barback/barback.dart'; | |
| 10 import 'package:scheduled_test/scheduled_test.dart'; | |
| 11 | |
| 12 import '../utils.dart'; | |
| 13 | |
| 14 main() { | |
| 15 initConfig(); | |
| 16 test("runs transforms in a group", () { | |
| 17 initGraph(["app|foo.a"], {"app": [ | |
| 18 [new TransformerGroup([ | |
| 19 [new RewriteTransformer("a", "b")], | |
| 20 [new RewriteTransformer("b", "c")] | |
| 21 ])] | |
| 22 ]}); | |
| 23 updateSources(["app|foo.a"]); | |
| 24 expectAsset("app|foo.c", "foo.b.c"); | |
| 25 buildShouldSucceed(); | |
| 26 }); | |
| 27 | |
| 28 test("passes the output of a group to the next phase", () { | |
| 29 initGraph(["app|foo.a"], {"app": [ | |
| 30 [new TransformerGroup([ | |
| 31 [new RewriteTransformer("a", "b")], | |
| 32 [new RewriteTransformer("b", "c")] | |
| 33 ])], | |
| 34 [new RewriteTransformer("c", "d")] | |
| 35 ]}); | |
| 36 updateSources(["app|foo.a"]); | |
| 37 expectAsset("app|foo.d", "foo.b.c.d"); | |
| 38 buildShouldSucceed(); | |
| 39 }); | |
| 40 | |
| 41 test("passes the output of a previous phase to a group", () { | |
| 42 initGraph(["app|foo.a"], {"app": [ | |
| 43 [new RewriteTransformer("a", "b")], | |
| 44 [new TransformerGroup([ | |
| 45 [new RewriteTransformer("b", "c")], | |
| 46 [new RewriteTransformer("c", "d")] | |
| 47 ])] | |
| 48 ]}); | |
| 49 updateSources(["app|foo.a"]); | |
| 50 expectAsset("app|foo.d", "foo.b.c.d"); | |
| 51 buildShouldSucceed(); | |
| 52 }); | |
| 53 | |
| 54 test("intermediate assets in a group are usable as secondary inputs within " | |
| 55 "that group", () { | |
| 56 initGraph({ | |
| 57 "app|foo.a": "contents", | |
| 58 "app|bar.txt": "foo.inc" | |
| 59 }, {"app": [ | |
| 60 [new TransformerGroup([ | |
| 61 [new RewriteTransformer("a", "inc")], | |
| 62 [new ManyToOneTransformer("txt")] | |
| 63 ])] | |
| 64 ]}); | |
| 65 | |
| 66 updateSources(["app|foo.a", "app|bar.txt"]); | |
| 67 expectAsset("app|bar.out", "contents.inc"); | |
| 68 buildShouldSucceed(); | |
| 69 }); | |
| 70 | |
| 71 test("groups can be nested", () { | |
| 72 initGraph(["app|foo.a", "app|bar.x"], {"app": [ | |
| 73 [new TransformerGroup([ | |
| 74 [new TransformerGroup([ | |
| 75 [new RewriteTransformer("a", "b")], | |
| 76 [new RewriteTransformer("b", "c")] | |
| 77 ]), new TransformerGroup([ | |
| 78 [new RewriteTransformer("x", "y"), new RewriteTransformer("a", "y")], | |
| 79 [new RewriteTransformer("y", "z")] | |
| 80 ])], | |
| 81 [new RewriteTransformer("c", "d")] | |
| 82 ])] | |
| 83 ]}); | |
| 84 updateSources(["app|foo.a", "app|bar.x"]); | |
| 85 expectAsset("app|foo.d", "foo.b.c.d"); | |
| 86 expectAsset("app|foo.z", "foo.y.z"); | |
| 87 expectAsset("app|bar.z", "bar.y.z"); | |
| 88 buildShouldSucceed(); | |
| 89 }); | |
| 90 | |
| 91 test("an updated asset is propagated through a group", () { | |
| 92 initGraph(["app|foo.a"], {"app": [ | |
| 93 [new TransformerGroup([ | |
| 94 [new RewriteTransformer("a", "b")], | |
| 95 [new RewriteTransformer("b", "c")] | |
| 96 ])] | |
| 97 ]}); | |
| 98 | |
| 99 updateSources(["app|foo.a"]); | |
| 100 expectAsset("app|foo.c", "foo.b.c"); | |
| 101 buildShouldSucceed(); | |
| 102 | |
| 103 modifyAsset("app|foo.a", "new foo"); | |
| 104 updateSources(["app|foo.a"]); | |
| 105 expectAsset("app|foo.c", "new foo.b.c"); | |
| 106 buildShouldSucceed(); | |
| 107 }); | |
| 108 | |
| 109 test("an updated asset only runs the necessary transforms in a group", () { | |
| 110 var rewriteA = new RewriteTransformer("a", "b"); | |
| 111 var rewriteX = new RewriteTransformer("x", "b"); | |
| 112 initGraph(["app|foo.a", "app|bar.x"], {"app": [ | |
| 113 [new TransformerGroup([ | |
| 114 [rewriteA, rewriteX], | |
| 115 [new RewriteTransformer("b", "c")] | |
| 116 ])] | |
| 117 ]}); | |
| 118 | |
| 119 updateSources(["app|foo.a", "app|bar.x"]); | |
| 120 expectAsset("app|foo.c", "foo.b.c"); | |
| 121 expectAsset("app|bar.c", "bar.b.c"); | |
| 122 buildShouldSucceed(); | |
| 123 | |
| 124 modifyAsset("app|foo.a", "new foo"); | |
| 125 updateSources(["app|foo.a"]); | |
| 126 expectAsset("app|foo.c", "new foo.b.c"); | |
| 127 buildShouldSucceed(); | |
| 128 | |
| 129 expect(rewriteA.numRuns, completion(equals(2))); | |
| 130 expect(rewriteX.numRuns, completion(equals(1))); | |
| 131 }); | |
| 132 | |
| 133 group("encapsulation", () { | |
| 134 test("a group can't see a parallel transform's outputs", () { | |
| 135 initGraph(["app|foo.x"], {"app": [[ | |
| 136 new TransformerGroup([ | |
| 137 [new RewriteTransformer("a", "b")], | |
| 138 [new RewriteTransformer("b", "c")] | |
| 139 ]), | |
| 140 new RewriteTransformer("x", "b") | |
| 141 ]]}); | |
| 142 updateSources(["app|foo.x"]); | |
| 143 expectAsset("app|foo.b", "foo.b"); | |
| 144 expectNoAsset("app|foo.c"); | |
| 145 buildShouldSucceed(); | |
| 146 }); | |
| 147 | |
| 148 test("a parallel transform can't see a group's outputs", () { | |
| 149 initGraph(["app|foo.a"], {"app": [[ | |
| 150 new TransformerGroup([ | |
| 151 [new RewriteTransformer("a", "b")], | |
| 152 [new RewriteTransformer("b", "c")] | |
| 153 ]), | |
| 154 new RewriteTransformer("c", "z") | |
| 155 ]]}); | |
| 156 updateSources(["app|foo.a"]); | |
| 157 expectAsset("app|foo.c", "foo.b.c"); | |
| 158 expectNoAsset("app|foo.z"); | |
| 159 buildShouldSucceed(); | |
| 160 }); | |
| 161 | |
| 162 test("a parallel transform can't see a group's intermediate assets", () { | |
| 163 initGraph(["app|foo.a"], {"app": [[ | |
| 164 new TransformerGroup([ | |
| 165 [new RewriteTransformer("a", "b")], | |
| 166 [new RewriteTransformer("b", "c")] | |
| 167 ]), | |
| 168 new RewriteTransformer("b", "z") | |
| 169 ]]}); | |
| 170 updateSources(["app|foo.a"]); | |
| 171 expectAsset("app|foo.c", "foo.b.c"); | |
| 172 expectNoAsset("app|foo.z"); | |
| 173 buildShouldSucceed(); | |
| 174 }); | |
| 175 | |
| 176 test("parallel groups can't see one another's intermediate assets", () { | |
| 177 initGraph(["app|foo.a", "app|bar.x"], {"app": [ | |
| 178 [new TransformerGroup([ | |
| 179 [new RewriteTransformer("a", "b")], | |
| 180 [new RewriteTransformer("b", "c")] | |
| 181 ]), new TransformerGroup([ | |
| 182 [new RewriteTransformer("x", "b")], | |
| 183 [new RewriteTransformer("b", "z")] | |
| 184 ])] | |
| 185 ]}); | |
| 186 updateSources(["app|foo.a", "app|bar.x"]); | |
| 187 expectAsset("app|foo.c", "foo.b.c"); | |
| 188 expectAsset("app|bar.z", "bar.b.z"); | |
| 189 expectNoAsset("app|foo.z"); | |
| 190 expectNoAsset("app|bar.c"); | |
| 191 buildShouldSucceed(); | |
| 192 }); | |
| 193 | |
| 194 test("parallel groups' intermediate assets can't collide", () { | |
| 195 initGraph(["app|foo.a", "app|foo.x"], {"app": [ | |
| 196 [new TransformerGroup([ | |
| 197 [new RewriteTransformer("a", "b")], | |
| 198 [new RewriteTransformer("b", "c")..consumePrimary = true] | |
| 199 ]), new TransformerGroup([ | |
| 200 [new RewriteTransformer("x", "b")], | |
| 201 [new RewriteTransformer("b", "z")..consumePrimary = true] | |
| 202 ])] | |
| 203 ]}); | |
| 204 updateSources(["app|foo.a", "app|foo.x"]); | |
| 205 expectAsset("app|foo.a"); | |
| 206 expectAsset("app|foo.x"); | |
| 207 expectAsset("app|foo.c", "foo.b.c"); | |
| 208 expectAsset("app|foo.z", "foo.b.z"); | |
| 209 buildShouldSucceed(); | |
| 210 }); | |
| 211 }); | |
| 212 | |
| 213 group("pass-through", () { | |
| 214 test("passes an unused input through a group", () { | |
| 215 initGraph(["app|foo.x"], {"app": [ | |
| 216 [new TransformerGroup([ | |
| 217 [new RewriteTransformer("a", "b")], | |
| 218 [new RewriteTransformer("b", "c")] | |
| 219 ])] | |
| 220 ]}); | |
| 221 updateSources(["app|foo.x"]); | |
| 222 expectNoAsset("app|foo.c"); | |
| 223 expectAsset("app|foo.x", "foo"); | |
| 224 buildShouldSucceed(); | |
| 225 }); | |
| 226 | |
| 227 test("passes non-overwritten inputs through a group", () { | |
| 228 initGraph(["app|foo.a"], {"app": [ | |
| 229 [new TransformerGroup([ | |
| 230 [new RewriteTransformer("a", "b")], | |
| 231 [new RewriteTransformer("b", "c")] | |
| 232 ])] | |
| 233 ]}); | |
| 234 updateSources(["app|foo.a"]); | |
| 235 expectAsset("app|foo.a", "foo"); | |
| 236 expectAsset("app|foo.b", "foo.b"); | |
| 237 expectAsset("app|foo.c", "foo.b.c"); | |
| 238 buildShouldSucceed(); | |
| 239 }); | |
| 240 | |
| 241 test("passes an unused input through parallel groups", () { | |
| 242 initGraph(["app|foo.x"], {"app": [ | |
| 243 [new TransformerGroup([ | |
| 244 [new RewriteTransformer("a", "b")], | |
| 245 [new RewriteTransformer("b", "c")] | |
| 246 ]), new TransformerGroup([ | |
| 247 [new RewriteTransformer("1", "2")], | |
| 248 [new RewriteTransformer("2", "3")] | |
| 249 ])] | |
| 250 ]}); | |
| 251 updateSources(["app|foo.x"]); | |
| 252 expectNoAsset("app|foo.c"); | |
| 253 expectNoAsset("app|foo.3"); | |
| 254 expectAsset("app|foo.x", "foo"); | |
| 255 buildShouldSucceed(); | |
| 256 }); | |
| 257 | |
| 258 test("passes an unused input through a group and a transform", () { | |
| 259 initGraph(["app|foo.x"], {"app": [[ | |
| 260 new TransformerGroup([ | |
| 261 [new RewriteTransformer("a", "b")], | |
| 262 [new RewriteTransformer("b", "c")] | |
| 263 ]), | |
| 264 new RewriteTransformer("1", "2") | |
| 265 ]]}); | |
| 266 updateSources(["app|foo.x"]); | |
| 267 expectNoAsset("app|foo.c"); | |
| 268 expectNoAsset("app|foo.2"); | |
| 269 expectAsset("app|foo.x", "foo"); | |
| 270 buildShouldSucceed(); | |
| 271 }); | |
| 272 | |
| 273 test("doesn't pass through an input that's overwritten by a group but not " | |
| 274 "by transformers", () { | |
| 275 initGraph(["app|foo.a"], {"app": [[ | |
| 276 new TransformerGroup([ | |
| 277 [new RewriteTransformer("a", "a")], | |
| 278 ]), | |
| 279 new RewriteTransformer("x", "y") | |
| 280 ]]}); | |
| 281 updateSources(["app|foo.a"]); | |
| 282 expectNoAsset("app|foo.y"); | |
| 283 expectAsset("app|foo.a", "foo.a"); | |
| 284 buildShouldSucceed(); | |
| 285 }); | |
| 286 | |
| 287 test("doesn't pass through an input that's overwritten by transformers but " | |
| 288 "not by a group", () { | |
| 289 initGraph(["app|foo.x"], {"app": [[ | |
| 290 new TransformerGroup([ | |
| 291 [new RewriteTransformer("a", "b")], | |
| 292 [new RewriteTransformer("b", "c")] | |
| 293 ]), | |
| 294 new RewriteTransformer("x", "x") | |
| 295 ]]}); | |
| 296 updateSources(["app|foo.x"]); | |
| 297 expectNoAsset("app|foo.c"); | |
| 298 expectAsset("app|foo.x", "foo.x"); | |
| 299 buildShouldSucceed(); | |
| 300 }); | |
| 301 | |
| 302 test("doesn't pass through an input that's consumed by a group but not " | |
| 303 "by transformers", () { | |
| 304 initGraph(["app|foo.a"], {"app": [[ | |
| 305 new TransformerGroup([ | |
| 306 [new RewriteTransformer("a", "b")..consumePrimary = true], | |
| 307 ]), | |
| 308 new RewriteTransformer("x", "y") | |
| 309 ]]}); | |
| 310 updateSources(["app|foo.a"]); | |
| 311 expectNoAsset("app|foo.a"); | |
| 312 expectAsset("app|foo.b", "foo.b"); | |
| 313 buildShouldSucceed(); | |
| 314 }); | |
| 315 | |
| 316 test("doesn't pass through an input that's consumed by transformers but " | |
| 317 "not by a group", () { | |
| 318 initGraph(["app|foo.x"], {"app": [[ | |
| 319 new TransformerGroup([ | |
| 320 [new RewriteTransformer("a", "b")], | |
| 321 [new RewriteTransformer("b", "c")] | |
| 322 ]), | |
| 323 new RewriteTransformer("x", "y")..consumePrimary = true | |
| 324 ]]}); | |
| 325 updateSources(["app|foo.x"]); | |
| 326 expectNoAsset("app|foo.x"); | |
| 327 expectAsset("app|foo.y", "foo.y"); | |
| 328 buildShouldSucceed(); | |
| 329 }); | |
| 330 | |
| 331 test("doesn't detect a collision for an input that's modified in-place by " | |
| 332 "a transformer", () { | |
| 333 initGraph(["app|foo.x"], {"app": [[ | |
| 334 new TransformerGroup([ | |
| 335 [new RewriteTransformer("a", "b")], | |
| 336 [new RewriteTransformer("b", "c")] | |
| 337 ]), | |
| 338 new RewriteTransformer("x", "x") | |
| 339 ]]}); | |
| 340 updateSources(["app|foo.x"]); | |
| 341 expectAsset("app|foo.x", "foo.x"); | |
| 342 buildShouldSucceed(); | |
| 343 }); | |
| 344 | |
| 345 test("doesn't detect a collision for an input that's modified in-place by " | |
| 346 "a group", () { | |
| 347 initGraph(["app|foo.a"], {"app": [[ | |
| 348 new TransformerGroup([[new RewriteTransformer("a", "a")]]), | |
| 349 new RewriteTransformer("x", "y") | |
| 350 ]]}); | |
| 351 updateSources(["app|foo.a"]); | |
| 352 expectAsset("app|foo.a", "foo.a"); | |
| 353 buildShouldSucceed(); | |
| 354 }); | |
| 355 }); | |
| 356 | |
| 357 test("runs transforms in an added group", () { | |
| 358 var rewrite = new RewriteTransformer("a", "z"); | |
| 359 initGraph(["app|foo.a"], {"app": [[rewrite]]}); | |
| 360 | |
| 361 updateSources(["app|foo.a"]); | |
| 362 expectAsset("app|foo.z", "foo.z"); | |
| 363 buildShouldSucceed(); | |
| 364 | |
| 365 updateTransformers("app", [[ | |
| 366 rewrite, | |
| 367 new TransformerGroup([ | |
| 368 [new RewriteTransformer("a", "b")], | |
| 369 [new RewriteTransformer("b", "c")] | |
| 370 ]) | |
| 371 ]]); | |
| 372 expectAsset("app|foo.z", "foo.z"); | |
| 373 expectAsset("app|foo.c", "foo.b.c"); | |
| 374 buildShouldSucceed(); | |
| 375 }); | |
| 376 | |
| 377 test("doesn't re-run transforms in a re-added group", () { | |
| 378 var rewrite1 = new RewriteTransformer("a", "b"); | |
| 379 var rewrite2 = new RewriteTransformer("b", "c"); | |
| 380 var group = new TransformerGroup([[rewrite1], [rewrite2]]); | |
| 381 initGraph(["app|foo.a"], {"app": [[group]]}); | |
| 382 | |
| 383 updateSources(["app|foo.a"]); | |
| 384 expectAsset("app|foo.c", "foo.b.c"); | |
| 385 buildShouldSucceed(); | |
| 386 | |
| 387 updateTransformers("app", [ | |
| 388 [group, new RewriteTransformer("a", "z")] | |
| 389 ]); | |
| 390 expectAsset("app|foo.c", "foo.b.c"); | |
| 391 expectAsset("app|foo.z", "foo.z"); | |
| 392 buildShouldSucceed(); | |
| 393 | |
| 394 expect(rewrite1.numRuns, completion(equals(1))); | |
| 395 expect(rewrite2.numRuns, completion(equals(1))); | |
| 396 }); | |
| 397 | |
| 398 test("doesn't run transforms in a removed group", () { | |
| 399 var rewrite1 = new RewriteTransformer("a", "b"); | |
| 400 var rewrite2 = new RewriteTransformer("b", "c"); | |
| 401 var group = new TransformerGroup([[rewrite1], [rewrite2]]); | |
| 402 initGraph(["app|foo.a"], {"app": [[group]]}); | |
| 403 | |
| 404 updateSources(["app|foo.a"]); | |
| 405 expectAsset("app|foo.c", "foo.b.c"); | |
| 406 buildShouldSucceed(); | |
| 407 | |
| 408 updateTransformers("app", []); | |
| 409 expectNoAsset("app|foo.c"); | |
| 410 buildShouldSucceed(); | |
| 411 }); | |
| 412 | |
| 413 test("doesn't pass through an input that's overwritten by an added group", | |
| 414 () { | |
| 415 var rewrite = new RewriteTransformer("x", "z"); | |
| 416 initGraph(["app|foo.a"], {"app": [[rewrite]]}); | |
| 417 | |
| 418 updateSources(["app|foo.a"]); | |
| 419 expectAsset("app|foo.a", "foo"); | |
| 420 buildShouldSucceed(); | |
| 421 | |
| 422 updateTransformers("app", [ | |
| 423 [rewrite, new TransformerGroup([[new RewriteTransformer("a", "a")]])] | |
| 424 ]); | |
| 425 expectAsset("app|foo.a", "foo.a"); | |
| 426 buildShouldSucceed(); | |
| 427 }); | |
| 428 | |
| 429 // TODO(nweiz): make the collision error message nice | |
| 430 test("reports collisions within a group", () { | |
| 431 initGraph(["app|foo.a", "app|foo.x"], {"app": [ | |
| 432 [new TransformerGroup([ | |
| 433 [new RewriteTransformer("a", "b")], | |
| 434 [new RewriteTransformer("x", "b")] | |
| 435 ])] | |
| 436 ]}); | |
| 437 updateSources(["app|foo.a", "app|foo.x"]); | |
| 438 buildShouldFail([isAssetCollisionException("app|foo.b")]); | |
| 439 }); | |
| 440 | |
| 441 test("reports collisions between a group and a non-grouped transform", () { | |
| 442 initGraph(["app|foo.a", "app|foo.x"], {"app": [[ | |
| 443 new TransformerGroup([ | |
| 444 [new RewriteTransformer("a", "b")], | |
| 445 [new RewriteTransformer("b", "c")] | |
| 446 ]), | |
| 447 new RewriteTransformer("x", "c") | |
| 448 ]]}); | |
| 449 updateSources(["app|foo.a", "app|foo.x"]); | |
| 450 buildShouldFail([isAssetCollisionException("app|foo.c")]); | |
| 451 }); | |
| 452 | |
| 453 // Regression test for issue 18872. | |
| 454 test("a multi-phase group's outputs should be visible as secondary inputs " | |
| 455 "for a following group", () { | |
| 456 initGraph({ | |
| 457 "app|foo.txt": "bar.c", | |
| 458 "app|bar.a": "bar" | |
| 459 }, {"app": [ | |
| 460 [new TransformerGroup([ | |
| 461 [new RewriteTransformer("a", "b")], | |
| 462 [new RewriteTransformer("b", "c")] | |
| 463 ])], | |
| 464 [new TransformerGroup([ | |
| 465 [new ManyToOneTransformer("txt")] | |
| 466 ])] | |
| 467 ]}); | |
| 468 | |
| 469 updateSources(["app|foo.txt", "app|bar.a"]); | |
| 470 expectAsset("app|foo.out", "bar.b.c"); | |
| 471 buildShouldSucceed(); | |
| 472 }); | |
| 473 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 808713003:
Remove barback from the repo. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart