OLD | NEW |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 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 | 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. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library barback.test.package_graph.transform_test; | 5 library barback.test.package_graph.transform_test; |
6 | 6 |
7 import 'package:barback/src/utils.dart'; | 7 import 'package:barback/src/utils.dart'; |
8 import 'package:scheduled_test/scheduled_test.dart'; | 8 import 'package:scheduled_test/scheduled_test.dart'; |
9 | 9 |
10 import '../utils.dart'; | 10 import '../utils.dart'; |
11 | 11 |
12 main() { | 12 main() { |
13 initConfig(); | 13 initConfig(); |
14 test("a new transformer is applied to a matching asset", () { | 14 test("a new transformer is applied to a matching asset", () { |
15 initGraph(["app|foo.blub"]); | 15 initGraph(["app|foo.blub"]); |
16 | 16 |
17 updateSources(["app|foo.blub"]); | 17 updateSources(["app|foo.blub"]); |
18 expectAsset("app|foo.blub", "foo"); | 18 expectAsset("app|foo.blub", "foo"); |
19 buildShouldSucceed(); | 19 buildShouldSucceed(); |
20 | 20 |
21 updateTransformers("app", [[new RewriteTransformer("blub", "blab")]]); | 21 updateTransformers("app", [ |
| 22 [new RewriteTransformer("blub", "blab")] |
| 23 ]); |
22 expectAsset("app|foo.blab", "foo.blab"); | 24 expectAsset("app|foo.blab", "foo.blab"); |
23 buildShouldSucceed(); | 25 buildShouldSucceed(); |
24 }); | 26 }); |
25 | 27 |
26 test("a new transformer is not applied to a non-matching asset", () { | 28 test("a new transformer is not applied to a non-matching asset", () { |
27 initGraph(["app|foo.blub"]); | 29 initGraph(["app|foo.blub"]); |
28 | 30 |
29 updateSources(["app|foo.blub"]); | 31 updateSources(["app|foo.blub"]); |
30 expectAsset("app|foo.blub", "foo"); | 32 expectAsset("app|foo.blub", "foo"); |
31 buildShouldSucceed(); | 33 buildShouldSucceed(); |
32 | 34 |
33 updateTransformers("app", [[new RewriteTransformer("zip", "zap")]]); | 35 updateTransformers("app", [ |
| 36 [new RewriteTransformer("zip", "zap")] |
| 37 ]); |
34 expectAsset("app|foo.blub", "foo"); | 38 expectAsset("app|foo.blub", "foo"); |
35 expectNoAsset("app|foo.zap"); | 39 expectNoAsset("app|foo.zap"); |
36 buildShouldSucceed(); | 40 buildShouldSucceed(); |
37 }); | 41 }); |
38 | 42 |
39 test("updateTransformers doesn't re-run an old transformer", () { | 43 test("updateTransformers doesn't re-run an old transformer", () { |
40 var rewrite = new RewriteTransformer("blub", "blab"); | 44 var rewrite = new RewriteTransformer("blub", "blab"); |
41 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | 45 initGraph([ |
| 46 "app|foo.blub" |
| 47 ], { |
| 48 "app": [ |
| 49 [rewrite] |
| 50 ] |
| 51 }); |
42 | 52 |
43 updateSources(["app|foo.blub"]); | 53 updateSources(["app|foo.blub"]); |
44 expectAsset("app|foo.blab", "foo.blab"); | 54 expectAsset("app|foo.blab", "foo.blab"); |
45 buildShouldSucceed(); | 55 buildShouldSucceed(); |
46 | 56 |
47 updateTransformers("app", [[rewrite]]); | 57 updateTransformers("app", [ |
| 58 [rewrite] |
| 59 ]); |
48 expectAsset("app|foo.blab", "foo.blab"); | 60 expectAsset("app|foo.blab", "foo.blab"); |
49 buildShouldSucceed(); | 61 buildShouldSucceed(); |
50 | 62 |
51 expect(rewrite.numRuns, completion(equals(1))); | 63 expect(rewrite.numRuns, completion(equals(1))); |
52 }); | 64 }); |
53 | 65 |
54 test("updateTransformers re-runs old transformers in a new phase", () { | 66 test("updateTransformers re-runs old transformers in a new phase", () { |
55 var rewrite1 = new RewriteTransformer("txt", "blub"); | 67 var rewrite1 = new RewriteTransformer("txt", "blub"); |
56 var rewrite2 = new RewriteTransformer("blub", "blab"); | 68 var rewrite2 = new RewriteTransformer("blub", "blab"); |
57 initGraph(["app|foo.txt"], {"app": [[rewrite1], [rewrite2]]}); | 69 initGraph([ |
| 70 "app|foo.txt" |
| 71 ], { |
| 72 "app": [ |
| 73 [rewrite1], |
| 74 [rewrite2] |
| 75 ] |
| 76 }); |
58 | 77 |
59 updateSources(["app|foo.txt"]); | 78 updateSources(["app|foo.txt"]); |
60 expectAsset("app|foo.blab", "foo.blub.blab"); | 79 expectAsset("app|foo.blab", "foo.blub.blab"); |
61 buildShouldSucceed(); | 80 buildShouldSucceed(); |
62 | 81 |
63 updateTransformers("app", [[rewrite2], [rewrite1]]); | 82 updateTransformers("app", [ |
| 83 [rewrite2], |
| 84 [rewrite1] |
| 85 ]); |
64 expectAsset("app|foo.blub", "foo.blub"); | 86 expectAsset("app|foo.blub", "foo.blub"); |
65 expectNoAsset("app|foo.blab"); | 87 expectNoAsset("app|foo.blab"); |
66 buildShouldSucceed(); | 88 buildShouldSucceed(); |
67 }); | 89 }); |
68 | 90 |
69 test("updateTransformers re-runs an old transformer when a previous phase " | 91 test( |
| 92 "updateTransformers re-runs an old transformer when a previous phase " |
70 "changes", () { | 93 "changes", () { |
71 var rewrite = new RewriteTransformer("txt", "out"); | 94 var rewrite = new RewriteTransformer("txt", "out"); |
72 initGraph(["app|foo.txt"], {"app": [[], [rewrite]]}); | 95 initGraph([ |
| 96 "app|foo.txt" |
| 97 ], { |
| 98 "app": [ |
| 99 [], |
| 100 [rewrite] |
| 101 ] |
| 102 }); |
73 | 103 |
74 updateSources(["app|foo.txt"]); | 104 updateSources(["app|foo.txt"]); |
75 expectAsset("app|foo.out", "foo.out"); | 105 expectAsset("app|foo.out", "foo.out"); |
76 buildShouldSucceed(); | 106 buildShouldSucceed(); |
77 | 107 |
78 updateTransformers("app", [ | 108 updateTransformers("app", [ |
79 [new RewriteTransformer("txt", "txt")], | 109 [new RewriteTransformer("txt", "txt")], |
80 [rewrite] | 110 [rewrite] |
81 ]); | 111 ]); |
82 expectAsset("app|foo.out", "foo.txt.out"); | 112 expectAsset("app|foo.out", "foo.txt.out"); |
83 buildShouldSucceed(); | 113 buildShouldSucceed(); |
84 }); | 114 }); |
85 | 115 |
86 test("a removed transformer is no longer applied", () { | 116 test("a removed transformer is no longer applied", () { |
87 initGraph(["app|foo.blub"], {"app": [ | 117 initGraph([ |
88 [new RewriteTransformer("blub", "blab")] | 118 "app|foo.blub" |
89 ]}); | 119 ], { |
| 120 "app": [ |
| 121 [new RewriteTransformer("blub", "blab")] |
| 122 ] |
| 123 }); |
90 | 124 |
91 updateSources(["app|foo.blub"]); | 125 updateSources(["app|foo.blub"]); |
92 expectAsset("app|foo.blab", "foo.blab"); | 126 expectAsset("app|foo.blab", "foo.blab"); |
93 buildShouldSucceed(); | 127 buildShouldSucceed(); |
94 | 128 |
95 updateTransformers("app", []); | 129 updateTransformers("app", []); |
96 expectAsset("app|foo.blub", "foo"); | 130 expectAsset("app|foo.blub", "foo"); |
97 expectNoAsset("app|foo.blab"); | 131 expectNoAsset("app|foo.blab"); |
98 buildShouldSucceed(); | 132 buildShouldSucceed(); |
99 }); | 133 }); |
100 | 134 |
101 test("a new transformer is pipelined", () { | 135 test("a new transformer is pipelined", () { |
102 var rewrite1 = new RewriteTransformer("source", "phase1"); | 136 var rewrite1 = new RewriteTransformer("source", "phase1"); |
103 var rewrite3 = new RewriteTransformer("phase2", "phase3"); | 137 var rewrite3 = new RewriteTransformer("phase2", "phase3"); |
104 initGraph(["app|foo.source"], {"app": [ | 138 initGraph([ |
105 [rewrite1], | 139 "app|foo.source" |
106 [rewrite3] | 140 ], { |
107 ]}); | 141 "app": [ |
| 142 [rewrite1], |
| 143 [rewrite3] |
| 144 ] |
| 145 }); |
108 | 146 |
109 updateSources(["app|foo.source"]); | 147 updateSources(["app|foo.source"]); |
110 expectNoAsset("app|foo.phase3"); | 148 expectNoAsset("app|foo.phase3"); |
111 buildShouldSucceed(); | 149 buildShouldSucceed(); |
112 | 150 |
113 updateTransformers("app", [ | 151 updateTransformers("app", [ |
114 [rewrite1], | 152 [rewrite1], |
115 [new RewriteTransformer("phase1", "phase2")], | 153 [new RewriteTransformer("phase1", "phase2")], |
116 [rewrite3] | 154 [rewrite3] |
117 ]); | 155 ]); |
118 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); | 156 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); |
119 buildShouldSucceed(); | 157 buildShouldSucceed(); |
120 }); | 158 }); |
121 | 159 |
122 test("a removed transformer is un-pipelined", () { | 160 test("a removed transformer is un-pipelined", () { |
123 var rewrite1 = new RewriteTransformer("source", "phase1"); | 161 var rewrite1 = new RewriteTransformer("source", "phase1"); |
124 var rewrite3 = new RewriteTransformer("phase2", "phase3"); | 162 var rewrite3 = new RewriteTransformer("phase2", "phase3"); |
125 initGraph(["app|foo.source"], {"app": [ | 163 initGraph([ |
126 [rewrite1], | 164 "app|foo.source" |
127 [new RewriteTransformer("phase1", "phase2")], | 165 ], { |
128 [rewrite3] | 166 "app": [ |
129 ]}); | 167 [rewrite1], |
| 168 [new RewriteTransformer("phase1", "phase2")], |
| 169 [rewrite3] |
| 170 ] |
| 171 }); |
130 | 172 |
131 updateSources(["app|foo.source"]); | 173 updateSources(["app|foo.source"]); |
132 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); | 174 expectAsset("app|foo.phase3", "foo.phase1.phase2.phase3"); |
133 buildShouldSucceed(); | 175 buildShouldSucceed(); |
134 | 176 |
135 updateTransformers("app", [[rewrite1], [rewrite3]]); | 177 updateTransformers("app", [ |
| 178 [rewrite1], |
| 179 [rewrite3] |
| 180 ]); |
136 expectNoAsset("app|foo.phase3"); | 181 expectNoAsset("app|foo.phase3"); |
137 buildShouldSucceed(); | 182 buildShouldSucceed(); |
138 }); | 183 }); |
139 | 184 |
140 test("a transformer is removed during isPrimary", () { | 185 test("a transformer is removed during isPrimary", () { |
141 var rewrite = new RewriteTransformer("blub", "blab"); | 186 var rewrite = new RewriteTransformer("blub", "blab"); |
142 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | 187 initGraph([ |
| 188 "app|foo.blub" |
| 189 ], { |
| 190 "app": [ |
| 191 [rewrite] |
| 192 ] |
| 193 }); |
143 | 194 |
144 rewrite.pauseIsPrimary("app|foo.blub"); | 195 rewrite.pauseIsPrimary("app|foo.blub"); |
145 updateSources(["app|foo.blub"]); | 196 updateSources(["app|foo.blub"]); |
146 // Ensure we're waiting on [rewrite.isPrimary]. | 197 // Ensure we're waiting on [rewrite.isPrimary]. |
147 schedule(pumpEventQueue); | 198 schedule(pumpEventQueue); |
148 | 199 |
149 updateTransformers("app", []); | 200 updateTransformers("app", []); |
150 rewrite.resumeIsPrimary("app|foo.blub"); | 201 rewrite.resumeIsPrimary("app|foo.blub"); |
151 expectAsset("app|foo.blub", "foo"); | 202 expectAsset("app|foo.blub", "foo"); |
152 expectNoAsset("app|foo.blab"); | 203 expectNoAsset("app|foo.blab"); |
153 buildShouldSucceed(); | 204 buildShouldSucceed(); |
154 }); | 205 }); |
155 | 206 |
156 test("a transformer is removed during apply", () { | 207 test("a transformer is removed during apply", () { |
157 var rewrite = new RewriteTransformer("blub", "blab"); | 208 var rewrite = new RewriteTransformer("blub", "blab"); |
158 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | 209 initGraph([ |
| 210 "app|foo.blub" |
| 211 ], { |
| 212 "app": [ |
| 213 [rewrite] |
| 214 ] |
| 215 }); |
159 | 216 |
160 rewrite.pauseApply(); | 217 rewrite.pauseApply(); |
161 updateSources(["app|foo.blub"]); | 218 updateSources(["app|foo.blub"]); |
162 // Ensure we're waiting on [rewrite.apply]. | 219 // Ensure we're waiting on [rewrite.apply]. |
163 schedule(pumpEventQueue); | 220 schedule(pumpEventQueue); |
164 | 221 |
165 updateTransformers("app", []); | 222 updateTransformers("app", []); |
166 rewrite.resumeApply(); | 223 rewrite.resumeApply(); |
167 expectAsset("app|foo.blub", "foo"); | 224 expectAsset("app|foo.blub", "foo"); |
168 expectNoAsset("app|foo.blab"); | 225 expectNoAsset("app|foo.blab"); |
169 buildShouldSucceed(); | 226 buildShouldSucceed(); |
170 }); | 227 }); |
171 | 228 |
172 test("a transformer is added to an existing phase during isPrimary", () { | 229 test("a transformer is added to an existing phase during isPrimary", () { |
173 var rewrite = new RewriteTransformer("blub", "blab"); | 230 var rewrite = new RewriteTransformer("blub", "blab"); |
174 initGraph(["app|foo.blub", "app|bar.blib"], {"app": [[rewrite]]}); | 231 initGraph([ |
| 232 "app|foo.blub", |
| 233 "app|bar.blib" |
| 234 ], { |
| 235 "app": [ |
| 236 [rewrite] |
| 237 ] |
| 238 }); |
175 | 239 |
176 rewrite.pauseIsPrimary("app|foo.blub"); | 240 rewrite.pauseIsPrimary("app|foo.blub"); |
177 updateSources(["app|foo.blub", "app|bar.blib"]); | 241 updateSources(["app|foo.blub", "app|bar.blib"]); |
178 // Ensure we're waiting on [rewrite.isPrimary]. | 242 // Ensure we're waiting on [rewrite.isPrimary]. |
179 schedule(pumpEventQueue); | 243 schedule(pumpEventQueue); |
180 | 244 |
181 updateTransformers("app", [ | 245 updateTransformers("app", [ |
182 [rewrite, new RewriteTransformer("blib", "blob")] | 246 [rewrite, new RewriteTransformer("blib", "blob")] |
183 ]); | 247 ]); |
184 rewrite.resumeIsPrimary("app|foo.blub"); | 248 rewrite.resumeIsPrimary("app|foo.blub"); |
185 expectAsset("app|foo.blab", "foo.blab"); | 249 expectAsset("app|foo.blab", "foo.blab"); |
186 expectAsset("app|bar.blob", "bar.blob"); | 250 expectAsset("app|bar.blob", "bar.blob"); |
187 buildShouldSucceed(); | 251 buildShouldSucceed(); |
188 }); | 252 }); |
189 | 253 |
190 test("a cross-package transform sees a new transformer in a new phase", () { | 254 test("a cross-package transform sees a new transformer in a new phase", () { |
191 var rewrite = new RewriteTransformer("inc", "inc"); | 255 var rewrite = new RewriteTransformer("inc", "inc"); |
192 initGraph({ | 256 initGraph({ |
193 "pkg1|foo.txt": "pkg2|foo.inc", | 257 "pkg1|foo.txt": "pkg2|foo.inc", |
194 "pkg2|foo.inc": "foo" | 258 "pkg2|foo.inc": "foo" |
195 }, { | 259 }, { |
196 "pkg1": [[new ManyToOneTransformer("txt")]], | 260 "pkg1": [ |
197 "pkg2": [[rewrite]] | 261 [new ManyToOneTransformer("txt")] |
| 262 ], |
| 263 "pkg2": [ |
| 264 [rewrite] |
| 265 ] |
198 }); | 266 }); |
199 | 267 |
200 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); | 268 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); |
201 expectAsset("pkg1|foo.out", "foo.inc"); | 269 expectAsset("pkg1|foo.out", "foo.inc"); |
202 buildShouldSucceed(); | 270 buildShouldSucceed(); |
203 | 271 |
204 updateTransformers("pkg2", [ | 272 updateTransformers("pkg2", [ |
205 [rewrite], | 273 [rewrite], |
206 [new RewriteTransformer("inc", "inc")] | 274 [new RewriteTransformer("inc", "inc")] |
207 ]); | 275 ]); |
208 expectAsset("pkg1|foo.out", "foo.inc.inc"); | 276 expectAsset("pkg1|foo.out", "foo.inc.inc"); |
209 buildShouldSucceed(); | 277 buildShouldSucceed(); |
210 }); | 278 }); |
211 | 279 |
212 test("a cross-package transform doesn't see a removed transformer in a " | 280 test( |
| 281 "a cross-package transform doesn't see a removed transformer in a " |
213 "removed phase", () { | 282 "removed phase", () { |
214 var rewrite = new RewriteTransformer("inc", "inc"); | 283 var rewrite = new RewriteTransformer("inc", "inc"); |
215 initGraph({ | 284 initGraph({ |
216 "pkg1|foo.txt": "pkg2|foo.inc", | 285 "pkg1|foo.txt": "pkg2|foo.inc", |
217 "pkg2|foo.inc": "foo" | 286 "pkg2|foo.inc": "foo" |
218 }, { | 287 }, { |
219 "pkg1": [[new ManyToOneTransformer("txt")]], | 288 "pkg1": [ |
| 289 [new ManyToOneTransformer("txt")] |
| 290 ], |
220 "pkg2": [ | 291 "pkg2": [ |
221 [rewrite], | 292 [rewrite], |
222 [new RewriteTransformer("inc", "inc")] | 293 [new RewriteTransformer("inc", "inc")] |
223 ] | 294 ] |
224 }); | 295 }); |
225 | 296 |
226 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); | 297 updateSources(["pkg1|foo.txt", "pkg2|foo.inc"]); |
227 expectAsset("pkg1|foo.out", "foo.inc.inc"); | 298 expectAsset("pkg1|foo.out", "foo.inc.inc"); |
228 buildShouldSucceed(); | 299 buildShouldSucceed(); |
229 | 300 |
230 updateTransformers("pkg2", [[rewrite]]); | 301 updateTransformers("pkg2", [ |
| 302 [rewrite] |
| 303 ]); |
231 expectAsset("pkg1|foo.out", "foo.inc"); | 304 expectAsset("pkg1|foo.out", "foo.inc"); |
232 buildShouldSucceed(); | 305 buildShouldSucceed(); |
233 }); | 306 }); |
234 | 307 |
235 group("pass-through", () { | 308 group("pass-through", () { |
236 test("a new transformer can see pass-through assets", () { | 309 test("a new transformer can see pass-through assets", () { |
237 var rewrite = new RewriteTransformer("zip", "zap"); | 310 var rewrite = new RewriteTransformer("zip", "zap"); |
238 initGraph(["app|foo.blub"], {"app": [[rewrite]]}); | 311 initGraph([ |
| 312 "app|foo.blub" |
| 313 ], { |
| 314 "app": [ |
| 315 [rewrite] |
| 316 ] |
| 317 }); |
239 | 318 |
240 updateSources(["app|foo.blub"]); | 319 updateSources(["app|foo.blub"]); |
241 buildShouldSucceed(); | 320 buildShouldSucceed(); |
242 | 321 |
243 updateTransformers("app", [ | 322 updateTransformers("app", [ |
244 [rewrite], | 323 [rewrite], |
245 [new RewriteTransformer("blub", "blab")] | 324 [new RewriteTransformer("blub", "blab")] |
246 ]); | 325 ]); |
247 expectAsset("app|foo.blab", "foo.blab"); | 326 expectAsset("app|foo.blab", "foo.blab"); |
248 buildShouldSucceed(); | 327 buildShouldSucceed(); |
249 }); | 328 }); |
250 | 329 |
251 test("a new transformer can overwrite an old asset", () { | 330 test("a new transformer can overwrite an old asset", () { |
252 var rewrite = new RewriteTransformer("zip", "zap"); | 331 var rewrite = new RewriteTransformer("zip", "zap"); |
253 initGraph(["app|foo.txt"], {"app": [[rewrite]]}); | 332 initGraph([ |
| 333 "app|foo.txt" |
| 334 ], { |
| 335 "app": [ |
| 336 [rewrite] |
| 337 ] |
| 338 }); |
254 | 339 |
255 updateSources(["app|foo.txt"]); | 340 updateSources(["app|foo.txt"]); |
256 expectAsset("app|foo.txt", "foo"); | 341 expectAsset("app|foo.txt", "foo"); |
257 buildShouldSucceed(); | 342 buildShouldSucceed(); |
258 | 343 |
259 // Add a transformer that will overwrite the previously-passed-through | 344 // Add a transformer that will overwrite the previously-passed-through |
260 // "foo.txt" asset. The transformed asset should be emitted, not the | 345 // "foo.txt" asset. The transformed asset should be emitted, not the |
261 // passed-through asset. | 346 // passed-through asset. |
262 updateTransformers("app", [ | 347 updateTransformers("app", [ |
263 [rewrite, new RewriteTransformer("txt", "txt")] | 348 [rewrite, new RewriteTransformer("txt", "txt")] |
264 ]); | 349 ]); |
265 expectAsset("app|foo.txt", "foo.txt"); | 350 expectAsset("app|foo.txt", "foo.txt"); |
266 buildShouldSucceed(); | 351 buildShouldSucceed(); |
267 }); | 352 }); |
268 | 353 |
269 test("passes an asset through when an overwriting transform is removed", | 354 test("passes an asset through when an overwriting transform is removed", |
270 () { | 355 () { |
271 initGraph(["app|foo.txt"], { | 356 initGraph([ |
272 "app": [[new RewriteTransformer("txt", "txt")]] | 357 "app|foo.txt" |
| 358 ], { |
| 359 "app": [ |
| 360 [new RewriteTransformer("txt", "txt")] |
| 361 ] |
273 }); | 362 }); |
274 | 363 |
275 updateSources(["app|foo.txt"]); | 364 updateSources(["app|foo.txt"]); |
276 expectAsset("app|foo.txt", "foo.txt"); | 365 expectAsset("app|foo.txt", "foo.txt"); |
277 buildShouldSucceed(); | 366 buildShouldSucceed(); |
278 | 367 |
279 updateTransformers("app", [[]]); | 368 updateTransformers("app", [[]]); |
280 expectAsset("app|foo.txt", "foo"); | 369 expectAsset("app|foo.txt", "foo"); |
281 buildShouldSucceed(); | 370 buildShouldSucceed(); |
282 }); | 371 }); |
283 | 372 |
284 test("passes an asset through when its overwriting transform is removed " | 373 test( |
| 374 "passes an asset through when its overwriting transform is removed " |
285 "during apply", () { | 375 "during apply", () { |
286 var rewrite = new RewriteTransformer("txt", "txt"); | 376 var rewrite = new RewriteTransformer("txt", "txt"); |
287 initGraph(["app|foo.txt"], {"app": [[rewrite]]}); | 377 initGraph([ |
| 378 "app|foo.txt" |
| 379 ], { |
| 380 "app": [ |
| 381 [rewrite] |
| 382 ] |
| 383 }); |
288 | 384 |
289 rewrite.pauseApply(); | 385 rewrite.pauseApply(); |
290 updateSources(["app|foo.txt"]); | 386 updateSources(["app|foo.txt"]); |
291 expectAssetDoesNotComplete("app|foo.txt"); | 387 expectAssetDoesNotComplete("app|foo.txt"); |
292 | 388 |
293 updateTransformers("app", [[]]); | 389 updateTransformers("app", [[]]); |
294 rewrite.resumeApply(); | 390 rewrite.resumeApply(); |
295 expectAsset("app|foo.txt", "foo"); | 391 expectAsset("app|foo.txt", "foo"); |
296 buildShouldSucceed(); | 392 buildShouldSucceed(); |
297 }); | 393 }); |
298 | 394 |
299 test("doesn't pass an asset through when its overwriting transform is " | 395 test( |
| 396 "doesn't pass an asset through when its overwriting transform is " |
300 "removed during apply if another transform overwrites it", () { | 397 "removed during apply if another transform overwrites it", () { |
301 var rewrite1 = new RewriteTransformer("txt", "txt"); | 398 var rewrite1 = new RewriteTransformer("txt", "txt"); |
302 var rewrite2 = new RewriteTransformer("txt", "txt"); | 399 var rewrite2 = new RewriteTransformer("txt", "txt"); |
303 initGraph(["app|foo.txt"], {"app": [[rewrite1, rewrite2]]}); | 400 initGraph([ |
| 401 "app|foo.txt" |
| 402 ], { |
| 403 "app": [ |
| 404 [rewrite1, rewrite2] |
| 405 ] |
| 406 }); |
304 | 407 |
305 rewrite1.pauseApply(); | 408 rewrite1.pauseApply(); |
306 updateSources(["app|foo.txt"]); | 409 updateSources(["app|foo.txt"]); |
307 expectAsset("app|foo.txt", "foo.txt"); | 410 expectAsset("app|foo.txt", "foo.txt"); |
308 // Ensure we're waiting on [rewrite1.apply] | 411 // Ensure we're waiting on [rewrite1.apply] |
309 schedule(pumpEventQueue); | 412 schedule(pumpEventQueue); |
310 | 413 |
311 updateTransformers("app", [[rewrite2]]); | 414 updateTransformers("app", [ |
| 415 [rewrite2] |
| 416 ]); |
312 rewrite1.resumeApply(); | 417 rewrite1.resumeApply(); |
313 expectAsset("app|foo.txt", "foo.txt"); | 418 expectAsset("app|foo.txt", "foo.txt"); |
314 buildShouldSucceed(); | 419 buildShouldSucceed(); |
315 }); | 420 }); |
316 | 421 |
317 test("doesn't pass an asset through when one overwriting transform is " | 422 test( |
| 423 "doesn't pass an asset through when one overwriting transform is " |
318 "removed if another transform still overwrites it", () { | 424 "removed if another transform still overwrites it", () { |
319 var rewrite = new RewriteTransformer("txt", "txt"); | 425 var rewrite = new RewriteTransformer("txt", "txt"); |
320 initGraph(["app|foo.txt"], {"app": [[ | 426 initGraph([ |
321 rewrite, | 427 "app|foo.txt" |
322 new RewriteTransformer("txt", "txt") | 428 ], { |
323 ]]}); | 429 "app": [ |
| 430 [rewrite, new RewriteTransformer("txt", "txt")] |
| 431 ] |
| 432 }); |
324 | 433 |
325 updateSources(["app|foo.txt"]); | 434 updateSources(["app|foo.txt"]); |
326 // This could be either the output of [CheckContentTransformer] or | 435 // This could be either the output of [CheckContentTransformer] or |
327 // [RewriteTransformer], depending which completes first. | 436 // [RewriteTransformer], depending which completes first. |
328 expectAsset("app|foo.txt", anything); | 437 expectAsset("app|foo.txt", anything); |
329 buildShouldFail([isAssetCollisionException("app|foo.txt")]); | 438 buildShouldFail([isAssetCollisionException("app|foo.txt")]); |
330 | 439 |
331 updateTransformers("app", [[rewrite]]); | 440 updateTransformers("app", [ |
| 441 [rewrite] |
| 442 ]); |
332 expectAsset("app|foo.txt", "foo.txt"); | 443 expectAsset("app|foo.txt", "foo.txt"); |
333 buildShouldSucceed(); | 444 buildShouldSucceed(); |
334 }); | 445 }); |
335 }); | 446 }); |
336 | 447 |
337 // Regression test. | 448 // Regression test. |
338 test("a phase is added, then an input is removed and re-added", () { | 449 test("a phase is added, then an input is removed and re-added", () { |
339 var rewrite = new RewriteTransformer("txt", "mid"); | 450 var rewrite = new RewriteTransformer("txt", "mid"); |
340 initGraph(["app|foo.txt"], { | 451 initGraph([ |
341 "app": [[rewrite]] | 452 "app|foo.txt" |
| 453 ], { |
| 454 "app": [ |
| 455 [rewrite] |
| 456 ] |
342 }); | 457 }); |
343 | 458 |
344 updateSources(["app|foo.txt"]); | 459 updateSources(["app|foo.txt"]); |
345 expectAsset("app|foo.mid", "foo.mid"); | 460 expectAsset("app|foo.mid", "foo.mid"); |
346 buildShouldSucceed(); | 461 buildShouldSucceed(); |
347 | 462 |
348 updateTransformers("app", [ | 463 updateTransformers("app", [ |
349 [rewrite], | 464 [rewrite], |
350 [new RewriteTransformer("mid", "out")] | 465 [new RewriteTransformer("mid", "out")] |
351 ]); | 466 ]); |
352 expectAsset("app|foo.out", "foo.mid.out"); | 467 expectAsset("app|foo.out", "foo.mid.out"); |
353 buildShouldSucceed(); | 468 buildShouldSucceed(); |
354 | 469 |
355 removeSources(["app|foo.txt"]); | 470 removeSources(["app|foo.txt"]); |
356 expectNoAsset("app|foo.out"); | 471 expectNoAsset("app|foo.out"); |
357 buildShouldSucceed(); | 472 buildShouldSucceed(); |
358 | 473 |
359 updateSources(["app|foo.txt"]); | 474 updateSources(["app|foo.txt"]); |
360 expectAsset("app|foo.out", "foo.mid.out"); | 475 expectAsset("app|foo.out", "foo.mid.out"); |
361 buildShouldSucceed(); | 476 buildShouldSucceed(); |
362 }); | 477 }); |
363 | 478 |
364 // Regression test for issue 19540. | 479 // Regression test for issue 19540. |
365 test("a phase is removed and then one of its inputs is updated", () { | 480 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. | 481 // Have an empty first phase because the first phase is never removed. |
367 initGraph(["app|foo.txt"], { | 482 initGraph([ |
368 "app": [[], [new RewriteTransformer("txt", "out")]] | 483 "app|foo.txt" |
| 484 ], { |
| 485 "app": [ |
| 486 [], |
| 487 [new RewriteTransformer("txt", "out")] |
| 488 ] |
369 }); | 489 }); |
370 | 490 |
371 updateSources(["app|foo.txt"]); | 491 updateSources(["app|foo.txt"]); |
372 expectAsset("app|foo.out", "foo.out"); | 492 expectAsset("app|foo.out", "foo.out"); |
373 buildShouldSucceed(); | 493 buildShouldSucceed(); |
374 | 494 |
375 // First empty both phases. This allows the second phase to be considered | 495 // First empty both phases. This allows the second phase to be considered |
376 // idle even when its transformer is no longer running. | 496 // idle even when its transformer is no longer running. |
377 updateTransformers("app", [[], []]); | 497 updateTransformers("app", [[], []]); |
378 buildShouldSucceed(); | 498 buildShouldSucceed(); |
379 | 499 |
380 // Now remove the second phase. It should unsubscribe from its input's | 500 // Now remove the second phase. It should unsubscribe from its input's |
381 // events. | 501 // events. |
382 updateTransformers("app", [[]]); | 502 updateTransformers("app", [[]]); |
383 buildShouldSucceed(); | 503 buildShouldSucceed(); |
384 | 504 |
385 // Update the input. With issue 19540, this would cause the removed phase to | 505 // Update the input. With issue 19540, this would cause the removed phase to |
386 // try to update its status, which would crash. | 506 // try to update its status, which would crash. |
387 updateSources(["app|foo.txt"]); | 507 updateSources(["app|foo.txt"]); |
388 buildShouldSucceed(); | 508 buildShouldSucceed(); |
389 }); | 509 }); |
390 } | 510 } |
OLD | NEW |