OLD | NEW |
| (Empty) |
1 // Copyright (c) 2014, 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 pub_tests; | |
6 | |
7 import 'package:scheduled_test/scheduled_test.dart'; | |
8 | |
9 import '../descriptor.dart' as d; | |
10 import '../test_pub.dart'; | |
11 import 'utils.dart'; | |
12 | |
13 void main() { | |
14 initConfig(); | |
15 | |
16 integration( | |
17 "reports previous transformers as dependencies if the " | |
18 "transformer is transformed", | |
19 () { | |
20 // The root app just exists so that something is transformed by pkg and qux. | |
21 d.dir(appPath, [d.pubspec({ | |
22 "name": "myapp", | |
23 "version": "1.0.0", | |
24 "dependencies": { | |
25 "pkg": { | |
26 "path": "../pkg" | |
27 }, | |
28 "qux": { | |
29 "path": "../qux" | |
30 } | |
31 }, | |
32 "transformers": ["pkg", "qux"] | |
33 })]).create(); | |
34 | |
35 d.dir("pkg", [d.pubspec({ | |
36 "name": "pkg", | |
37 "version": "1.0.0", | |
38 "dependencies": { | |
39 "foo": { | |
40 "path": "../foo" | |
41 }, | |
42 "bar": { | |
43 "path": "../bar" | |
44 }, | |
45 "baz": { | |
46 "path": "../baz" | |
47 }, | |
48 }, | |
49 "transformers": [{ | |
50 "foo": { | |
51 "\$include": "lib/pkg.dart" | |
52 } | |
53 }, { | |
54 "bar": { | |
55 "\$exclude": "lib/transformer.dart" | |
56 } | |
57 }, "baz"] | |
58 }), | |
59 d.dir( | |
60 "lib", | |
61 [d.file("pkg.dart", ""), d.file("transformer.dart", transformer())
])]).create(); | |
62 | |
63 // Even though foo and bar don't modify pkg/lib/transformer.dart themselves, | |
64 // it may be modified to import a library that they modify or generate, so | |
65 // pkg will depend on them. | |
66 d.dir( | |
67 "foo", | |
68 [ | |
69 d.libPubspec("foo", "1.0.0"), | |
70 d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
71 | |
72 d.dir( | |
73 "bar", | |
74 [ | |
75 d.libPubspec("bar", "1.0.0"), | |
76 d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
77 | |
78 // baz transforms pkg/lib/transformer.dart, so pkg will obviously | |
79 // depend on it. | |
80 d.dir( | |
81 "baz", | |
82 [ | |
83 d.libPubspec("baz", "1.0.0"), | |
84 d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
85 | |
86 // qux doesn't transform anything in pkg, so pkg won't depend on it. | |
87 d.dir( | |
88 "qux", | |
89 [ | |
90 d.libPubspec("qux", "1.0.0"), | |
91 d.dir("lib", [d.file("qux.dart", transformer())])]).create(); | |
92 | |
93 expectDependencies({ | |
94 'pkg': ['foo', 'bar', 'baz'], | |
95 'foo': [], | |
96 'bar': [], | |
97 'baz': [], | |
98 'qux': [] | |
99 }); | |
100 }); | |
101 | |
102 integration( | |
103 "reports all transitive package dependencies' transformers as " | |
104 "dependencies if the transformer is transformed", | |
105 () { | |
106 // The root app just exists so that something is transformed by pkg and qux. | |
107 d.dir(appPath, [d.pubspec({ | |
108 "name": "myapp", | |
109 "dependencies": { | |
110 "pkg": { | |
111 "path": "../pkg" | |
112 }, | |
113 "qux": { | |
114 "path": "../qux" | |
115 } | |
116 }, | |
117 "transformers": ["pkg"] | |
118 })]).create(); | |
119 | |
120 d.dir("pkg", [d.pubspec({ | |
121 "name": "pkg", | |
122 "version": "1.0.0", | |
123 "dependencies": { | |
124 "foo": { | |
125 "path": "../foo" | |
126 }, | |
127 "baz": { | |
128 "path": "../baz" | |
129 } | |
130 }, | |
131 "transformers": ["baz"] | |
132 }), d.dir("lib", [d.file("pkg.dart", transformer())])]).create(); | |
133 | |
134 // pkg depends on foo. Even though it's not transformed by foo, its | |
135 // transformed transformer could import foo, so it has to depend on foo. | |
136 d.dir("foo", [d.pubspec({ | |
137 "name": "foo", | |
138 "version": "1.0.0", | |
139 "dependencies": { | |
140 "bar": { | |
141 "path": "../bar" | |
142 } | |
143 }, | |
144 "transformers": ["foo"] | |
145 }), d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
146 | |
147 // foo depends on bar, and like pkg's dependency on foo, the transformed | |
148 // version of foo's transformer could import bar, so foo has to depend on | |
149 // bar. | |
150 d.dir("bar", [d.pubspec({ | |
151 "name": "bar", | |
152 "version": "1.0.0", | |
153 "transformers": ["bar"] | |
154 }), d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
155 | |
156 /// foo is transformed by baz. | |
157 d.dir( | |
158 "baz", | |
159 [ | |
160 d.libPubspec("baz", "1.0.0"), | |
161 d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
162 | |
163 /// qux is not part of pkg's transitive dependency tree, so pkg shouldn't | |
164 /// depend on it. | |
165 d.dir("qux", [d.pubspec({ | |
166 "name": "qux", | |
167 "version": "1.0.0", | |
168 "transformers": ["qux"] | |
169 }), d.dir("lib", [d.file("qux.dart", transformer())])]).create(); | |
170 | |
171 expectDependencies({ | |
172 'pkg': ['foo', 'bar', 'baz'], | |
173 'foo': [], | |
174 'bar': [], | |
175 'baz': [], | |
176 'qux': [] | |
177 }); | |
178 }); | |
179 | |
180 integration( | |
181 "reports previous transformers as dependencies if a " | |
182 "nonexistent local file is imported", | |
183 () { | |
184 // The root app just exists so that something is transformed by pkg and bar. | |
185 d.dir(appPath, [d.pubspec({ | |
186 "name": "myapp", | |
187 "dependencies": { | |
188 "pkg": { | |
189 "path": "../pkg" | |
190 }, | |
191 "bar": { | |
192 "path": "../bar" | |
193 } | |
194 }, | |
195 "transformers": ["pkg", "bar"] | |
196 })]).create(); | |
197 | |
198 d.dir("pkg", [d.pubspec({ | |
199 "name": "pkg", | |
200 "version": "1.0.0", | |
201 "dependencies": { | |
202 "foo": { | |
203 "path": "../foo" | |
204 }, | |
205 "bar": { | |
206 "path": "../bar" | |
207 } | |
208 }, | |
209 "transformers": [{ | |
210 "foo": { | |
211 "\$include": "lib/pkg.dart" | |
212 } | |
213 }] | |
214 }), | |
215 d.dir( | |
216 "lib", | |
217 [ | |
218 d.file("pkg.dart", ""), | |
219 d.file("transformer.dart", transformer(["nonexistent.dart"]))]
)]).create(); | |
220 | |
221 // Since pkg's transformer imports a nonexistent file, we assume that file | |
222 // was generated by foo's transformer. Thus pkg's transformer depends on | |
223 // foo's even though the latter doesn't transform the former. | |
224 d.dir( | |
225 "foo", | |
226 [ | |
227 d.libPubspec("foo", "1.0.0"), | |
228 d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
229 | |
230 /// qux is not part of pkg's transitive dependency tree, so pkg shouldn't | |
231 /// depend on it. | |
232 d.dir( | |
233 "bar", | |
234 [ | |
235 d.libPubspec("bar", "1.0.0"), | |
236 d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
237 | |
238 expectDependencies({ | |
239 'pkg': ['foo'], | |
240 'foo': [], | |
241 'bar': [] | |
242 }); | |
243 }); | |
244 | |
245 integration( | |
246 "reports all that package's dependencies' transformers as " | |
247 "dependencies if a non-existent file is imported from another package"
, | |
248 () { | |
249 d.dir(appPath, [d.pubspec({ | |
250 "name": "myapp", | |
251 "dependencies": { | |
252 "foo": { | |
253 "path": "../foo" | |
254 }, | |
255 "qux": { | |
256 "path": "../qux" | |
257 } | |
258 }, | |
259 "transformers": ["myapp"] | |
260 }), | |
261 d.dir( | |
262 "lib", | |
263 [ | |
264 d.file( | |
265 "myapp.dart", | |
266 transformer(["package:foo/nonexistent.dart"]))])]).create(
); | |
267 | |
268 // myapp imported a nonexistent file from foo so myapp will depend on every | |
269 // transformer transitively reachable from foo, since the nonexistent file | |
270 // could be generated to import anything. | |
271 d.dir("foo", [d.pubspec({ | |
272 "name": "foo", | |
273 "version": "1.0.0", | |
274 "dependencies": { | |
275 "bar": { | |
276 "path": "../bar" | |
277 }, | |
278 "baz": { | |
279 "path": "../baz" | |
280 } | |
281 }, | |
282 "transformers": ["foo"] | |
283 }), d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
284 | |
285 // bar is a dependency of foo so myapp will depend on it. | |
286 d.dir("bar", [d.pubspec({ | |
287 "name": "bar", | |
288 "version": "1.0.0", | |
289 "transformers": ["bar"] | |
290 }), d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
291 | |
292 // baz is a dependency of foo so myapp will depend on it. | |
293 d.dir("baz", [d.pubspec({ | |
294 "name": "baz", | |
295 "version": "1.0.0", | |
296 "transformers": ["baz"] | |
297 }), d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
298 | |
299 // qux is not transitively reachable from foo so myapp won't depend on it. | |
300 d.dir("qux", [d.pubspec({ | |
301 "name": "qux", | |
302 "version": "1.0.0", | |
303 "transformers": ["qux"] | |
304 }), d.dir("lib", [d.file("qux.dart", transformer())])]).create(); | |
305 | |
306 expectDependencies({ | |
307 'myapp': ['foo', 'bar', 'baz'], | |
308 'foo': [], | |
309 'bar': [], | |
310 'baz': [], | |
311 'qux': [] | |
312 }); | |
313 }); | |
314 | |
315 integration( | |
316 "reports all that package's dependencies' transformers as " | |
317 "dependencies if a non-existent transformer is used from another packa
ge", | |
318 () { | |
319 d.dir(appPath, [d.pubspec({ | |
320 "name": "myapp", | |
321 "dependencies": { | |
322 "foo": { | |
323 "path": "../foo" | |
324 }, | |
325 "qux": { | |
326 "path": "../qux" | |
327 } | |
328 }, | |
329 "transformers": ["myapp"] | |
330 }), | |
331 d.dir( | |
332 "lib", | |
333 [ | |
334 d.file( | |
335 "myapp.dart", | |
336 transformer(["package:foo/nonexistent.dart"]))])]).create(
); | |
337 | |
338 // myapp imported a nonexistent file from foo so myapp will depend on every | |
339 // transformer transitively reachable from foo, since the nonexistent file | |
340 // could be generated to import anything. | |
341 d.dir("foo", [d.pubspec({ | |
342 "name": "foo", | |
343 "version": "1.0.0", | |
344 "dependencies": { | |
345 "bar": { | |
346 "path": "../bar" | |
347 }, | |
348 "baz": { | |
349 "path": "../baz" | |
350 } | |
351 }, | |
352 "transformers": ["bar"] | |
353 })]).create(); | |
354 | |
355 // bar is a dependency of foo so myapp will depend on it. | |
356 d.dir( | |
357 "bar", | |
358 [ | |
359 d.libPubspec("bar", "1.0.0"), | |
360 d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
361 | |
362 // baz is a dependency of foo so myapp will depend on it. | |
363 d.dir("baz", [d.pubspec({ | |
364 "name": "baz", | |
365 "version": "1.0.0", | |
366 "transformers": ["baz"] | |
367 }), d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
368 | |
369 // qux is not transitively reachable from foo so myapp won't depend on it. | |
370 d.dir("qux", [d.pubspec({ | |
371 "name": "qux", | |
372 "version": "1.0.0", | |
373 "transformers": ["qux"] | |
374 }), d.dir("lib", [d.file("qux.dart", transformer())])]).create(); | |
375 | |
376 expectDependencies({ | |
377 'myapp': ['bar', 'baz'], | |
378 'bar': [], | |
379 'baz': [], | |
380 'qux': [] | |
381 }); | |
382 }); | |
383 | |
384 test("reports dependencies on transformers in past phases", () { | |
385 d.dir(appPath, [d.pubspec({ | |
386 "name": "myapp", | |
387 "transformers": ["myapp/first", "myapp/second", "myapp/third"] | |
388 }), | |
389 d.dir( | |
390 "lib", | |
391 [ | |
392 d.file("first.dart", transformer()), | |
393 d.file("second.dart", transformer()), | |
394 d.file("third.dart", transformer())])]).create(); | |
395 | |
396 expectDependencies({ | |
397 'myapp/first': [], | |
398 'myapp/second': ['myapp/first'], | |
399 'myapp/third': ['myapp/second', 'myapp/first'] | |
400 }); | |
401 }); | |
402 | |
403 integration( | |
404 "considers the entrypoint package's dev and override " "dependencies", | |
405 () { | |
406 d.dir(appPath, [d.pubspec({ | |
407 "name": "myapp", | |
408 "dependencies": { | |
409 "foo": { | |
410 "path": "../foo" | |
411 } | |
412 }, | |
413 "dev_dependencies": { | |
414 "bar": { | |
415 "path": "../bar" | |
416 } | |
417 }, | |
418 "dependency_overrides": { | |
419 "baz": { | |
420 "path": "../baz" | |
421 } | |
422 }, | |
423 "transformers": ["foo", "myapp"] | |
424 }), d.dir("lib", [d.file("myapp.dart", transformer())])]).create(); | |
425 | |
426 // foo transforms myapp's transformer so it could import from bar or baz. | |
427 d.dir("foo", [d.pubspec({ | |
428 "name": "foo", | |
429 "version": "1.0.0", | |
430 "transformers": ["foo"] | |
431 }), d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
432 | |
433 // bar is a dev dependency that myapp could import from, so myapp should | |
434 // depend on it. | |
435 d.dir("bar", [d.pubspec({ | |
436 "name": "bar", | |
437 "version": "1.0.0", | |
438 "transformers": ["bar"] | |
439 }), d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
440 | |
441 // baz is an override dependency that myapp could import from, so myapp | |
442 // should depend on it. | |
443 d.dir("baz", [d.pubspec({ | |
444 "name": "baz", | |
445 "version": "1.0.0", | |
446 "transformers": ["baz"] | |
447 }), d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
448 | |
449 expectDependencies({ | |
450 'myapp': ['foo', 'bar', 'baz'], | |
451 'foo': [], | |
452 'bar': [], | |
453 'baz': [] | |
454 }); | |
455 }); | |
456 | |
457 integration( | |
458 "doesn't consider a non-entrypoint package's dev and override " "dependenc
ies", | |
459 () { | |
460 // myapp just exists so that pkg isn't the entrypoint. | |
461 d.dir(appPath, [d.pubspec({ | |
462 "name": "myapp", | |
463 "dependencies": { | |
464 "pkg": { | |
465 "path": "../pkg" | |
466 } | |
467 } | |
468 })]).create(); | |
469 | |
470 d.dir("pkg", [d.pubspec({ | |
471 "name": "pkg", | |
472 "dependencies": { | |
473 "foo": { | |
474 "path": "../foo" | |
475 } | |
476 }, | |
477 "dev_dependencies": { | |
478 "bar": { | |
479 "path": "../bar" | |
480 } | |
481 }, | |
482 "dependency_overrides": { | |
483 "baz": { | |
484 "path": "../baz" | |
485 } | |
486 }, | |
487 "transformers": ["foo", "pkg"] | |
488 }), d.dir("lib", [d.file("pkg.dart", transformer())])]).create(); | |
489 | |
490 // foo transforms pkg's transformer so it could theoretcially import from | |
491 // bar or baz. However, since pkg isn't the entrypoint, it doesn't have | |
492 // access to them. | |
493 d.dir("foo", [d.pubspec({ | |
494 "name": "foo", | |
495 "version": "1.0.0", | |
496 "transformers": ["foo"] | |
497 }), d.dir("lib", [d.file("foo.dart", transformer())])]).create(); | |
498 | |
499 // bar is a dev dependency that myapp can't import from, so myapp shouldn't | |
500 // depend on it. | |
501 d.dir("bar", [d.pubspec({ | |
502 "name": "bar", | |
503 "version": "1.0.0", | |
504 "transformers": ["bar"] | |
505 }), d.dir("lib", [d.file("bar.dart", transformer())])]).create(); | |
506 | |
507 // baz is a dev dependency that myapp can't import from, so myapp shouldn't | |
508 // depend on it. | |
509 d.dir("baz", [d.pubspec({ | |
510 "name": "baz", | |
511 "version": "1.0.0", | |
512 "transformers": ["baz"] | |
513 }), d.dir("lib", [d.file("baz.dart", transformer())])]).create(); | |
514 | |
515 expectDependencies({ | |
516 'pkg': ['foo'], | |
517 'foo': [], | |
518 'bar': [], | |
519 'baz': [] | |
520 }); | |
521 }); | |
522 } | |
OLD | NEW |