Debian Codegraph @

workspaces/arborist/test/can-place-dep.js

raw
1 // this test depends on debug stuff, so force it on, even if the test env
2 // does not enable it.
3 process.env.ARBORIST_DEBUG = '1'
4 const t = require('tap')
5 const CanPlaceDep = require('../lib/can-place-dep.js')
6 const {
7 CONFLICT,
8 OK,
9 REPLACE,
10 KEEP,
11 } = CanPlaceDep
12
13 const Node = require('../lib/node.js')
14
15 t.test('basic placement check tests', t => {
16 const path = '/some/path'
17
18 // boilerplate so we can define a bunch of test cases declaratively
19 const runTest = (desc, {
20 // the tree we're asking to add something into
21 tree,
22 // the target we're asking to add it in
23 targetLoc,
24 // the location of the node with the dependency
25 nodeLoc,
26 // the dep being added
27 dep,
28 // the expected overall result for the dep and its peers
29 expect,
30 // the expected result for the dep itself, ignoring peers
31 expectSelf,
32 // --prefer-dedupe set?
33 preferDedupe,
34 // array of nodes representing the dep's peer group
35 peerSet,
36 // is this dep the thing that the user is explicitly installing?
37 explicitRequest,
38 }) => {
39 const target = tree.inventory.get(targetLoc)
40 const node = tree.inventory.get(nodeLoc)
41 const edge = node.edgesOut.get(dep.name)
42 if (!dep.satisfies(edge)) {
43 edge.peerConflicted = true
44 }
45 const vr = new Node({
46 sourceReference: node,
47 path: node.path,
48 pkg: { ...node.package },
49 children: peerSet,
50 })
51 dep.parent = vr
52
53 // mark any invalid edges in the virtual root as peerConflicted
54 for (const child of vr.children.values()) {
55 for (const edgeIn of child.edgesIn) {
56 if (edgeIn.invalid) {
57 edgeIn.peerConflicted = true
58 }
59 }
60 }
61
62 const msg = `place ${
63 dep.package._id
64 } in ${targetLoc || 'ROOT'} for { ${
65 edge.from.location || 'ROOT'
66 } ${
67 edge.type + ' ' + edge.name + '@' + edge.spec
68 } }`
69
70 t.test(desc, t => {
71 const cpd = new CanPlaceDep({
72 target,
73 edge,
74 dep,
75 preferDedupe,
76 explicitRequest,
77 })
78 // dump a comment if the assertion fails.
79 // would put it in the diags, but yaml stringifies Set objects
80 // super awkwardly, and Node objects have a lot of those.
81 if (!t.equal(cpd.canPlace, expect, msg)) {
82 t.comment(cpd)
83 }
84 if (expectSelf) {
85 t.equal(cpd.canPlaceSelf, expectSelf, msg)
86 }
87 t.equal(cpd.description, cpd.canPlace.description || cpd.canPlace)
88 t.matchSnapshot([...cpd.conflictChildren].map(c => ({
89 dep: [c.dep.name, c.dep.version],
90 edge: [c.edge.from.location, c.edge.type, c.edge.name, c.edge.spec],
91 canPlace: c.canPlace,
92 canPlaceSelf: c.canPlaceSelf,
93 })), 'conflict children')
94 t.end()
95 })
96 }
97
98 runTest('basic placement of a dep, no conflicts or issues', {
99 tree: new Node({
100 path,
101 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
102 }),
103 targetLoc: '',
104 nodeLoc: '',
105 dep: new Node({
106 pkg: { name: 'a', version: '1.2.3' },
107 }),
108 expect: OK,
109 })
110
111 runTest('replace an existing dep', {
112 tree: new Node({
113 path,
114 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
115 children: [{ pkg: { name: 'a', version: '1.0.0' } }],
116 }),
117 targetLoc: '',
118 nodeLoc: '',
119 dep: new Node({ pkg: { name: 'a', version: '1.2.3' } }),
120 expect: REPLACE,
121 })
122
123 runTest('place nested', {
124 tree: new Node({
125 path,
126 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
127 children: [
128 { pkg: { name: 'a', version: '1.0.0' } },
129 {
130 pkg: { name: 'b', version: '1.0.0', dependencies: { a: '2.x' } },
131 },
132 ],
133 }),
134 targetLoc: 'node_modules/b',
135 nodeLoc: 'node_modules/b',
136 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
137 expect: OK,
138 })
139
140 runTest('conflict in root for nested dep', {
141 tree: new Node({
142 path,
143 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
144 children: [
145 { pkg: { name: 'a', version: '1.0.0' } },
146 { pkg: { name: 'b', version: '1.0.0', dependencies: { a: '2' } } },
147 ],
148 }),
149 targetLoc: '',
150 nodeLoc: 'node_modules/b',
151 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
152 expect: CONFLICT,
153 })
154
155 runTest('conflict in root for nested dep, no current', {
156 tree: new Node({
157 path,
158 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
159 children: [
160 { pkg: { name: 'b', version: '1.0.0', dependencies: { a: '2' } } },
161 ],
162 }),
163 targetLoc: '',
164 nodeLoc: 'node_modules/b',
165 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
166 expect: CONFLICT,
167 })
168
169 runTest('keep an existing dep that matches', {
170 tree: new Node({
171 path,
172 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1' } },
173 children: [
174 { pkg: { name: 'a', version: '1.2.3' } },
175 ],
176 }),
177 targetLoc: '',
178 nodeLoc: '',
179 dep: new Node({ pkg: { name: 'a', version: '1.2.3' } }),
180 expect: KEEP,
181 })
182
183 runTest('do not keep existing dep that matches, but does not satisfy', {
184 tree: new Node({
185 path,
186 pkg: { name: 'project', version: '1.2.3', dependencies: { a: 'foo/bar' } },
187 children: [
188 { pkg: { name: 'a', version: '1.2.3' } },
189 ],
190 }),
191 targetLoc: '',
192 nodeLoc: '',
193 dep: new Node({
194 pkg: { name: 'a', version: '1.2.3' },
195 resolved: 'git+ssh://github.com/foo/bar',
196 }),
197 expect: REPLACE,
198 })
199
200 runTest('keep existing dep that matches, does not satisfy, but peerConflicted', {
201 tree: new Node({
202 path,
203 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '2.3.4' } },
204 children: [
205 { pkg: { name: 'a', version: '1.2.3' } },
206 ],
207 }),
208 targetLoc: '',
209 nodeLoc: '',
210 dep: new Node({ pkg: { name: 'a', version: '1.2.3' } }),
211 expect: KEEP,
212 })
213
214 // https://github.com/npm/cli/issues/3411
215 runTest('replace an existing dep that matches, explicit request', {
216 tree: new Node({
217 path,
218 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1' } },
219 children: [
220 { pkg: { name: 'a', version: '1.2.3' } },
221 ],
222 }),
223 targetLoc: '',
224 nodeLoc: '',
225 dep: new Node({ pkg: { name: 'a', version: '1.2.3' } }),
226 expect: REPLACE,
227 explicitRequest: true,
228 })
229
230 runTest('replace an existing dep that could dedupe, explicit request', {
231 tree: new Node({
232 path,
233 pkg: { name: 'project',
234 version: '1.2.3',
235 dependencies: {
236 a: '*',
237 b: '1.2.3',
238 } },
239 children: [
240 { pkg: { name: 'a', version: '1.2.3' } },
241 { pkg: { name: 'b', version: '1.2.3', dependencies: { a: '1.2.3' } } },
242 ],
243 }),
244 targetLoc: '',
245 nodeLoc: '',
246 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
247 expect: REPLACE,
248 explicitRequest: true,
249 })
250
251 runTest('keep an existing dep that could dedupe, explicit request, preferDedupe', {
252 tree: new Node({
253 path,
254 pkg: { name: 'project',
255 version: '1.2.3',
256 dependencies: {
257 a: '*',
258 b: '1.2.3',
259 } },
260 children: [
261 { pkg: { name: 'a', version: '1.2.3' } },
262 { pkg: { name: 'b', version: '1.2.3', dependencies: { a: '1.2.3' } } },
263 ],
264 }),
265 targetLoc: '',
266 nodeLoc: '',
267 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
268 expect: KEEP,
269 preferDedupe: true,
270 explicitRequest: true,
271 })
272
273 runTest('keep an existing dep that is older, but also works', {
274 tree: new Node({
275 path,
276 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1', c: '2.0.0' } },
277 children: [
278 { pkg: { name: 'b', version: '2.0.0' } },
279 { pkg: { name: 'c', version: '2.0.0', dependencies: { b: '2.0.0' } } },
280 { pkg: { name: 'a', version: '1.2.3', dependencies: { b: '2' } } },
281 ],
282 }),
283 targetLoc: '',
284 nodeLoc: 'node_modules/a',
285 dep: new Node({ pkg: { name: 'b', version: '2.3.4' } }),
286 expect: KEEP,
287 })
288
289 runTest('replace an existing dep that is newer, because preferDedupe', {
290 tree: new Node({
291 path,
292 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1', c: '2.0.0' } },
293 children: [
294 { pkg: { name: 'b', version: '2.3.4' } },
295 { pkg: { name: 'c', version: '2.0.0', dependencies: { b: '2.0.0' } } },
296 { pkg: { name: 'a', version: '1.2.3', dependencies: { b: '2' } } },
297 ],
298 }),
299 targetLoc: '',
300 nodeLoc: 'node_modules/c',
301 dep: new Node({ pkg: { name: 'b', version: '2.0.0' } }),
302 expect: REPLACE,
303 preferDedupe: true,
304 })
305
306 runTest('conflict an existing dep that is newer, preferDedupe peerConflict', {
307 tree: new Node({
308 path,
309 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1', c: '2.0.0' } },
310 children: [
311 { pkg: { name: 'b', version: '2.3.4' } },
312 { pkg: { name: 'c', version: '2.0.0', dependencies: { b: '2.0.0' } } },
313 { pkg: { name: 'a', version: '1.2.3', dependencies: { b: '2' } } },
314 ],
315 }),
316 targetLoc: '',
317 nodeLoc: 'node_modules/c',
318 dep: new Node({
319 pkg: { name: 'b', version: '2.0.0', peerDependencies: { a: '3' } },
320 }),
321 peerSet: [
322 { pkg: { name: 'a', version: '3.0.0' } },
323 ],
324 expect: CONFLICT,
325 preferDedupe: true,
326 })
327
328 runTest('conflict an existing dep that is newer, because no preferDedupe', {
329 tree: new Node({
330 path,
331 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1', c: '2.0.0' } },
332 children: [
333 { pkg: { name: 'b', version: '2.3.4' } },
334 { pkg: { name: 'c', version: '2.0.0', dependencies: { b: '2.0.0' } } },
335 { pkg: { name: 'a', version: '1.2.3', dependencies: { b: '2' } } },
336 ],
337 }),
338 targetLoc: '',
339 nodeLoc: 'node_modules/c',
340 dep: new Node({ pkg: { name: 'b', version: '2.0.0' } }),
341 expect: CONFLICT,
342 preferDedupe: false,
343 })
344
345 // always OK or REPLACE if the dep being placed had errors
346 runTest('return REPLACE because node had errors', {
347 tree: new Node({
348 path,
349 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1' } },
350 children: [
351 { pkg: { name: 'a', version: '1.2.3' } },
352 ],
353 }),
354 targetLoc: '',
355 nodeLoc: '',
356 dep: new Node({
357 pkg: { name: 'a', version: '1.2.3' },
358 error: new Error('uh oh'),
359 }),
360 expect: REPLACE,
361 })
362 runTest('return OK because node had errors', {
363 tree: new Node({
364 path,
365 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
366 children: [
367 {
368 pkg: { name: 'b', version: '1.0.0', peerDependencies: { a: '2.x' } },
369 },
370 ],
371 }),
372 targetLoc: '',
373 nodeLoc: 'node_modules/b',
374 dep: new Node({
375 pkg: { name: 'a', version: '2.3.4' },
376 error: new Error('uh oh'),
377 }),
378 expect: OK,
379 })
380
381 runTest('cannot place peer inside of dependent', {
382 tree: new Node({
383 path,
384 pkg: { name: 'project', version: '1.2.3', dependencies: { b: '1.x' } },
385 children: [
386 {
387 pkg: { name: 'b', version: '1.0.0', peerDependencies: { a: '2.x' } },
388 },
389 ],
390 }),
391 targetLoc: 'node_modules/b',
392 nodeLoc: 'node_modules/b',
393 dep: new Node({ pkg: { name: 'a', version: '2.3.4' } }),
394 expect: CONFLICT,
395 })
396
397 // root -> (x)
398 // x -> (a, b@1)
399 // a -> (b@2)
400 // b@1 -> (c@1)
401 // b@2 -> (c@2)
402 //
403 // root
404 // +-- c@1
405 // +-- x
406 // +-- a
407 // | +-- b@2
408 // +-- b@1
409 // place c@2 in x, CONFLICT due to shadowing
410 runTest('invalid shadowing', {
411 tree: new Node({
412 path,
413 pkg: { dependencies: { x: '1' } },
414 children: [
415 { pkg: { name: 'c', version: '1.0.0' } },
416 {
417 pkg: { name: 'x', version: '1.0.0', dependencies: { a: '1', b: '1' } },
418 children: [
419 {
420 pkg: { name: 'a', version: '1.0.0', dependencies: { b: '2' } },
421 children: [
422 { pkg: { name: 'b', version: '2.0.0', dependencies: { c: '2' } } },
423 ],
424 },
425 { pkg: { name: 'b', version: '1.0.0', dependencies: { c: '1' } } },
426 ],
427 },
428 ],
429 }),
430 targetLoc: 'node_modules/x',
431 nodeLoc: 'node_modules/x/node_modules/a/node_modules/b',
432 dep: new Node({ pkg: { name: 'c', version: '2.0.0' } }),
433 expect: CONFLICT,
434 })
435
436 runTest('totally valid shadowing', {
437 tree: new Node({
438 path,
439 pkg: { dependencies: { x: '1' } },
440 children: [
441 { pkg: { name: 'c', version: '1.0.0' } },
442 {
443 pkg: { name: 'x', version: '1.0.0', dependencies: { a: '1', b: '1' } },
444 children: [
445 {
446 pkg: { name: 'a', version: '1.0.0', dependencies: { b: '2' } },
447 children: [
448 { pkg: { name: 'b', version: '2.0.0', dependencies: { c: '2' } } },
449 ],
450 },
451 // difference right here on the c@1||2 line
452 { pkg: { name: 'b', version: '1.0.0', dependencies: { c: '1||2' } } },
453 ],
454 },
455 ],
456 }),
457 targetLoc: 'node_modules/x',
458 nodeLoc: 'node_modules/x/node_modules/a/node_modules/b',
459 dep: new Node({ pkg: { name: 'c', version: '2.0.0' } }),
460 expect: OK,
461 })
462
463 // peer dep shenanigans
464 runTest('basic placement with peers', {
465 tree: new Node({
466 path,
467 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
468 }),
469 targetLoc: '',
470 nodeLoc: '',
471 dep: new Node({
472 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
473 }),
474 expect: OK,
475 peerSet: [
476 { pkg: { name: 'b', version: '1.2.3' } },
477 ],
478 })
479
480 runTest('peer with peers', {
481 tree: new Node({
482 path,
483 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
484 }),
485 targetLoc: '',
486 nodeLoc: '',
487 dep: new Node({
488 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
489 }),
490 expect: OK,
491 peerSet: [
492 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
493 { pkg: { name: 'c', version: '1.2.3' } },
494 ],
495 })
496
497 runTest('cycle of peers', {
498 tree: new Node({
499 path,
500 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
501 }),
502 targetLoc: '',
503 nodeLoc: '',
504 dep: new Node({
505 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
506 }),
507 expect: OK,
508 peerSet: [
509 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
510 { pkg: { name: 'c', version: '1.2.3', peerDependencies: { a: '1' } } },
511 ],
512 })
513
514 runTest('cycle of peers hanging off entry node', {
515 tree: new Node({
516 path,
517 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
518 }),
519 targetLoc: '',
520 nodeLoc: '',
521 dep: new Node({
522 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
523 }),
524 expect: OK,
525 peerSet: [
526 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
527 { pkg: { name: 'c', version: '1.2.3', peerDependencies: { d: '1' } } },
528 { pkg: { name: 'd', version: '1.2.3', peerDependencies: { b: '1' } } },
529 ],
530 })
531
532 runTest('peers with peerConflicted edges in peerSet', {
533 tree: new Node({
534 path,
535 pkg: { name: 'project', version: '1.2.3', dependencies: { a: '1.x' } },
536 }),
537 targetLoc: '',
538 nodeLoc: '',
539 dep: new Node({
540 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
541 }),
542 expect: OK,
543 peerSet: [
544 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
545 { pkg: { name: 'c', version: '1.2.3', peerDependencies: { b: '2', a: '2' } } },
546 ],
547 })
548
549 runTest('peers with peerConflicted edges in peerSet from dependent', {
550 tree: new Node({
551 path,
552 pkg: {
553 name: 'project',
554 version: '1.2.3',
555 dependencies: {
556 a: '1.x',
557 c: '2.x',
558 },
559 },
560 children: [
561 { pkg: { name: 'c', version: '2.0.1', peerDependencies: { b: '2', a: '2' } } },
562 ],
563 }),
564 targetLoc: '',
565 nodeLoc: '',
566 dep: new Node({
567 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
568 }),
569 expect: OK,
570 peerSet: [
571 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
572 { pkg: { name: 'c', version: '2.2.3', peerDependencies: { b: '2', a: '2' } } },
573 ],
574 })
575
576 runTest('replacing existing peer set', {
577 tree: new Node({
578 path,
579 pkg: {
580 name: 'project',
581 version: '1.2.3',
582 dependencies: {
583 a: '1.x',
584 c: '2.x',
585 },
586 },
587 children: [
588 { pkg: { name: 'a', version: '1.0.1', peerDependencies: { b: '1' } } },
589 { pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } } },
590 { pkg: { name: 'c', version: '2.0.1', peerDependencies: { b: '2', a: '2' } } },
591 ],
592 }),
593 targetLoc: '',
594 nodeLoc: '',
595 dep: new Node({
596 pkg: { name: 'a', version: '1.2.3', peerDependencies: { b: '1' } },
597 }),
598 expect: REPLACE,
599 peerSet: [
600 { pkg: { name: 'b', version: '1.2.3', peerDependencies: { c: '1' } } },
601 { pkg: { name: 'c', version: '2.2.3', peerDependencies: { b: '2', a: '2' } } },
602 ],
603 explicitRequest: true,
604 })
605
606 runTest('existing peer set which can be pushed deeper, no current', {
607 tree: new Node({
608 path,
609 pkg: {
610 name: 'project',
611 version: '1.2.3',
612 dependencies: {
613 a: '1.x',
614 d: '2.x',
615 },
616 },
617 children: [
618 { pkg: { name: 'a', version: '1.0.1', dependencies: { b: '1' } } },
619 { pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } } },
620 { pkg: { name: 'c', version: '1.0.1' } },
621 ],
622 }),
623 targetLoc: '',
624 nodeLoc: '',
625 dep: new Node({
626 pkg: { name: 'd', version: '2.2.2', peerDependencies: { b: '2' } },
627 }),
628 expect: OK,
629 peerSet: [
630 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
631 { pkg: { name: 'c', version: '2.2.2' } },
632 ],
633 explicitRequest: true,
634 })
635
636 runTest('existing peer set which can be pushed deeper, with invalid current', {
637 tree: new Node({
638 path,
639 pkg: {
640 name: 'project',
641 version: '1.2.3',
642 dependencies: {
643 a: '1.x',
644 d: '2.x',
645 },
646 },
647 children: [
648 { pkg: { name: 'a', version: '1.0.1', dependencies: { b: '1' } } },
649 { pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } } },
650 { pkg: { name: 'c', version: '1.0.1' } },
651 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { b: '1' } } },
652 ],
653 }),
654 targetLoc: '',
655 nodeLoc: '',
656 dep: new Node({
657 pkg: { name: 'd', version: '2.2.2', peerDependencies: { b: '2' } },
658 }),
659 expect: REPLACE,
660 peerSet: [
661 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
662 { pkg: { name: 'c', version: '2.2.2' } },
663 ],
664 explicitRequest: true,
665 })
666
667 // root -> (a@1, d@1)
668 // [email protected] -> (b@1)
669 // [email protected] -> PEER(c@1)
670 // [email protected] -> PEER(b@1)
671 // [email protected] -> PEER(b@2)
672 // [email protected] -> PEER(c@2)
673 //
674 // root
675 // +-- [email protected]
676 // +-- [email protected] <-- can be pushed under a, along with c & d
677 // +-- [email protected]
678 // +-- [email protected]
679 // PLACE([email protected]<[email protected], [email protected]>)
680 runTest('existing peer set which can be pushed deeper, with valid current', {
681 tree: new Node({
682 path,
683 pkg: {
684 name: 'project',
685 version: '1.2.3',
686 dependencies: {
687 a: '1.x',
688 d: '1.x',
689 },
690 },
691 children: [
692 { pkg: { name: 'a', version: '1.0.1', dependencies: { b: '1' } } },
693 { pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } } },
694 { pkg: { name: 'c', version: '1.0.1' } },
695 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { b: '1' } } },
696 ],
697 }),
698 targetLoc: '',
699 nodeLoc: '',
700 dep: new Node({
701 pkg: { name: 'd', version: '1.2.2', peerDependencies: { b: '2' } },
702 }),
703 expect: REPLACE,
704 peerSet: [
705 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
706 { pkg: { name: 'c', version: '2.2.2' } },
707 ],
708 explicitRequest: true,
709 })
710
711 runTest('existing peer set which can be pushed deeper, conflict on peer', {
712 tree: new Node({
713 path,
714 pkg: {
715 name: 'project',
716 version: '1.2.3',
717 dependencies: {
718 a: '1.x',
719 d: '1.x',
720 },
721 },
722 children: [
723 { pkg: { name: 'a', version: '1.0.1', dependencies: { bb: '1' } } },
724 { pkg: { name: 'bb', version: '1.0.1', peerDependencies: { c: '1' } } },
725 { pkg: { name: 'c', version: '1.0.1' } },
726 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { c: '1' } } },
727 ],
728 }),
729 targetLoc: '',
730 nodeLoc: '',
731 dep: new Node({
732 pkg: { name: 'd', version: '1.2.2', peerDependencies: { b: '2' } },
733 }),
734 expect: REPLACE,
735 peerSet: [
736 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
737 { pkg: { name: 'c', version: '2.2.2' } },
738 ],
739 explicitRequest: true,
740 })
741
742 runTest('existing peer set cannot be pushed deeper, but new dep set can', {
743 tree: new Node({
744 path,
745 pkg: {
746 name: 'project',
747 version: '1.2.3',
748 dependencies: {
749 a: '1.x',
750 d: '2.x',
751 },
752 },
753 children: [
754 { pkg: { name: 'a', version: '1.0.1', dependencies: { b: '1' } } },
755 { pkg: { name: 'd', version: '2.2.2', peerDependencies: { b: '2' } } },
756 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
757 { pkg: { name: 'c', version: '2.2.2' } },
758 ],
759 }),
760 targetLoc: '',
761 nodeLoc: 'node_modules/a',
762 dep: new Node({
763 pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } },
764 }),
765 expect: CONFLICT,
766 peerSet: [
767 { pkg: { name: 'c', version: '1.0.1' } },
768 ],
769 explicitRequest: true,
770 })
771
772 runTest('nest peer set under dependent node', {
773 tree: new Node({
774 path,
775 pkg: {
776 name: 'project',
777 version: '1.2.3',
778 dependencies: {
779 a: '1.x',
780 d: '2.x',
781 },
782 },
783 children: [
784 { pkg: { name: 'a', version: '1.0.1', dependencies: { b: '1' } } },
785 { pkg: { name: 'd', version: '2.2.2', peerDependencies: { b: '2' } } },
786 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
787 { pkg: { name: 'c', version: '2.2.2' } },
788 ],
789 }),
790 targetLoc: 'node_modules/a',
791 nodeLoc: 'node_modules/a',
792 dep: new Node({
793 pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } },
794 }),
795 expect: OK,
796 peerSet: [
797 { pkg: { name: 'c', version: '1.0.1' } },
798 ],
799 explicitRequest: true,
800 })
801
802 runTest('existing peer set cannot be pushed deeper, neither can new set', {
803 tree: new Node({
804 path,
805 pkg: {
806 name: 'project',
807 version: '1.2.3',
808 dependencies: {
809 a: '1.x',
810 d: '2.x',
811 },
812 },
813 children: [
814 { pkg: { name: 'a', version: '1.0.1', peerDependencies: { b: '1' } } },
815 { pkg: { name: 'd', version: '2.2.2', peerDependencies: { b: '2' } } },
816 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
817 { pkg: { name: 'c', version: '2.2.2' } },
818 ],
819 }),
820 targetLoc: '',
821 nodeLoc: 'node_modules/a',
822 dep: new Node({
823 pkg: { name: 'b', version: '1.0.1', peerDependencies: { c: '1' } },
824 }),
825 expect: CONFLICT,
826 peerSet: [
827 { pkg: { name: 'c', version: '1.0.1' } },
828 ],
829 explicitRequest: true,
830 })
831
832 runTest('existing peer set cannot be pushed deeper, neither can new set, conflict on peer', {
833 tree: new Node({
834 path,
835 pkg: {
836 name: 'project',
837 version: '1.2.3',
838 dependencies: {
839 a: '1.x',
840 d: '1.x',
841 },
842 },
843 children: [
844 // the bb dep could be nested, but it has a peerDep on c, and
845 // a would be fine with the c@2, but can't nest its c@1 dep
846 { pkg: { name: 'a', version: '1.0.1', dependencies: { bb: '1' }, peerDependencies: { c: '*' } } },
847 { pkg: { name: 'bb', version: '1.0.1', peerDependencies: { c: '1' } } },
848 { pkg: { name: 'c', version: '1.0.1' } },
849 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { c: '1' } } },
850 ],
851 }),
852 targetLoc: '',
853 nodeLoc: '',
854 dep: new Node({
855 pkg: { name: 'd', version: '1.2.2', peerDependencies: { b: '2' } },
856 }),
857 expect: CONFLICT,
858 peerSet: [
859 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
860 { pkg: { name: 'c', version: '2.2.2' } },
861 ],
862 explicitRequest: true,
863 })
864
865 // root -> (a@1, d@1)
866 // [email protected] -> (bb@1), PEER(c)
867 // [email protected] -> (cc@1), PEER(c)
868 // [email protected] -> PEER(dd@1)
869 // [email protected] -> PEER(c@1)
870 // [email protected] -> PEER(c)
871 // [email protected] -> PEER(b@2)
872 // [email protected] -> PEER(c@2)
873 //
874 // root
875 // +-- [email protected]
876 // +-- [email protected]
877 // +-- [email protected]
878 // +-- [email protected]
879 // +-- [email protected]
880 // +-- [email protected]
881 //
882 // PLACE [email protected] in root. peerSet(b@2, c@2)
883 // REPLACE [email protected]
884 // OK b@2 (no current, no conflicting edges)
885 // [email protected] -> [email protected]?
886 // entry edges:
887 // root->(a): no replacement
888 // a->(c): replacement satisfies
889 // a->(bb): not a peer edge
890 // >> can replace
891 // a->(bb):
892 // bb->(c): replacement satisfies
893 // bb->(cc): not a peer edge
894 // root->(d): is cpd peerEntryEdge, skip
895 // bb->(cc): no replacement
896 // dd->(cc): not a peer edge
897 // >> can replace
898
899 runTest('existing peer set cannot be pushed deeper, neither can new set, conflict on deep peer', {
900 tree: new Node({
901 path,
902 pkg: {
903 name: 'project',
904 version: '1.2.3',
905 dependencies: {
906 a: '1.x',
907 d: '1.x',
908 },
909 },
910 children: [
911 // the bb dep could be nested, but it has a peerDep on c, and
912 // a would be fine with the c@2, but can't nest its c@1 dep
913 { pkg: { name: 'a', version: '1.0.1', dependencies: { bb: '1' }, peerDependencies: { c: '*' } } },
914 { pkg: { name: 'bb', version: '1.0.1', dependencies: { cc: '1' }, peerDependencies: { c: '*' } } },
915 { pkg: { name: 'cc', version: '1.0.1', peerDependencies: { dd: '1' } } },
916 { pkg: { name: 'dd', version: '1.0.1', peerDependencies: { c: '1' } } },
917 { pkg: { name: 'c', version: '1.0.1' } },
918 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { c: '1' } } },
919 ],
920 }),
921 targetLoc: '',
922 nodeLoc: '',
923 dep: new Node({
924 pkg: { name: 'd', version: '1.2.2', peerDependencies: { b: '2' } },
925 }),
926 expect: CONFLICT,
927 peerSet: [
928 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '2' } } },
929 { pkg: { name: 'c', version: '2.2.2' } },
930 ],
931 explicitRequest: true,
932 })
933
934 runTest('existing peer set cannot be pushed deeper, neither can new set, replacement satisfies', {
935 tree: new Node({
936 path,
937 pkg: {
938 name: 'project',
939 version: '1.2.3',
940 dependencies: {
941 a: '1.x',
942 d: '1.x',
943 },
944 },
945 children: [
946 // the bb dep could be nested, but it has a peerDep on c, and
947 // a would be fine with the c@2, but can't nest its c@1 dep
948 { pkg: { name: 'a', version: '1.0.1', dependencies: { bb: '1' }, peerDependencies: { c: '*' } } },
949 { pkg: { name: 'bb', version: '1.0.1', dependencies: { cc: '1' }, peerDependencies: { c: '*' } } },
950 { pkg: { name: 'cc', version: '1.0.1', dependencies: { dd: '1' }, peerDependencies: { c: '*' } } },
951 { pkg: { name: 'dd', version: '1.0.1', peerDependencies: { c: '1' } } },
952 { pkg: { name: 'c', version: '1.0.1' } },
953 { pkg: { name: 'd', version: '1.1.1', peerDependencies: { c: '1' } } },
954 ],
955 }),
956 targetLoc: '',
957 nodeLoc: '',
958 dep: new Node({
959 pkg: { name: 'd', version: '1.2.2', peerDependencies: { b: '2' } },
960 }),
961 expect: REPLACE,
962 peerSet: [
963 { pkg: { name: 'b', version: '2.2.2', peerDependencies: { c: '1' } } },
964 { pkg: { name: 'c', version: '1.2.2' } },
965 ],
966 explicitRequest: true,
967 })
968
969 // root -> (a)
970 // a -> (b, c) PEER(p)
971 // b -> (c@1, d@2) PEER(p)
972 // c@1 -> (d@1) PEER(p)
973 // c@2 -> (d@2) PEER(p)
974 // d@1 -> PEER(p@1)
975 // d@2 -> PEER(p@2)
976 // root
977 // +-- a
978 // +-- b
979 // | +-- c@1
980 // | +-- d@1 <-- cannot place p@1 peer dep!
981 // +-- p@2
982 // +-- c@2
983 // +-- d@2
984 runTest('peer all the way down, conflict but not ours', {
985 tree: new Node({
986 path,
987 pkg: { dependencies: { a: '' } },
988 children: [
989 {
990 pkg: {
991 name: 'a',
992 version: '1.0.0',
993 dependencies: { b: '', c: '' },
994 peerDependencies: { p: '' },
995 },
996 },
997 {
998 pkg: {
999 name: 'b',
1000 version: '1.0.0',
1001 dependencies: { c: '1', d: '2' },
1002 peerDependencies: { p: '' },
1003 },
1004 children: [
1005 {
1006 pkg: {
1007 name: 'c',
1008 version: '1.0.0',
1009 dependencies: { d: '1' }, // <-- the dep we'll try to place
1010 peerDependencies: { p: '' },
1011 },
1012 },
1013 ],
1014 },
1015 { pkg: { name: 'p', version: '2.0.0' } },
1016 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { p: '' } } },
1017 { pkg: { name: 'd', version: '2.0.0', peerDependencies: { p: '2' } } },
1018 ],
1019 }),
1020 dep: new Node({
1021 pkg: { name: 'd', version: '1.0.0', peerDependencies: { p: '1' } },
1022 }),
1023 peerSet: [{ pkg: { name: 'p', version: '1.0.0' } }],
1024 nodeLoc: 'node_modules/b/node_modules/c',
1025 targetLoc: 'node_modules/b/node_modules/c',
1026 expect: CONFLICT,
1027 expectSelf: OK,
1028 })
1029
1030 // root -> (a@1, b@2)
1031 // a@1 -> PEER(b@1)
1032 // b@1 -> PEER(c@1)
1033 // c@1 -> PEER(d@1)
1034 // d@1 -> PEER(e@1)
1035 // e@1 -> PEER(a@1)
1036 // a@2 -> PEER(b@2)
1037 // b@2 -> PEER(c@2)
1038 // c@2 -> PEER(d@2)
1039 // d@2 -> PEER(e@2)
1040 // e@2 -> PEER(a@2)
1041 // root
1042 // +-- a@1
1043 // +-- b@1
1044 // +-- c@1
1045 // +-- d@1
1046 // +-- e@1
1047 // place b@2, peerSet (c@2, d@2, e@2, a@2)
1048 runTest('prod dep directly on conflicted peer, newer', {
1049 tree: new Node({
1050 path,
1051 pkg: { dependencies: { a: '1', b: '2' } },
1052 children: [
1053 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { b: '1' } } },
1054 { pkg: { name: 'b', version: '1.0.0', peerDependencies: { c: '1' } } },
1055 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { d: '1' } } },
1056 { pkg: { name: 'd', version: '1.0.0', peerDependencies: { e: '1' } } },
1057 { pkg: { name: 'e', version: '1.0.0', peerDependencies: { a: '1' } } },
1058 ],
1059 }),
1060 dep: new Node({
1061 pkg: { name: 'b', version: '2.0.0', peerDependencies: { c: '2' } },
1062 }),
1063 peerSet: [
1064 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { b: '2' } } },
1065 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { d: '2' } } },
1066 { pkg: { name: 'd', version: '2.0.0', peerDependencies: { e: '2' } } },
1067 { pkg: { name: 'e', version: '2.0.0', peerDependencies: { a: '2' } } },
1068 ],
1069 nodeLoc: '',
1070 targetLoc: '',
1071 expect: CONFLICT,
1072 expectSelf: REPLACE,
1073 })
1074
1075 runTest('prod dep directly on conflicted peer, older', {
1076 tree: new Node({
1077 path,
1078 pkg: { dependencies: { a: '2', b: '1' } },
1079 children: [
1080 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { b: '2' } } },
1081 { pkg: { name: 'b', version: '2.0.0', peerDependencies: { c: '2' } } },
1082 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { d: '2' } } },
1083 { pkg: { name: 'd', version: '2.0.0', peerDependencies: { e: '2' } } },
1084 { pkg: { name: 'e', version: '2.0.0', peerDependencies: { a: '2' } } },
1085 ],
1086 }),
1087 dep: new Node({
1088 pkg: { name: 'b', version: '1.0.0', peerDependencies: { c: '1' } },
1089 }),
1090 peerSet: [
1091 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { b: '1' } } },
1092 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { d: '1' } } },
1093 { pkg: { name: 'd', version: '1.0.0', peerDependencies: { e: '1' } } },
1094 { pkg: { name: 'e', version: '1.0.0', peerDependencies: { a: '1' } } },
1095 ],
1096 nodeLoc: '',
1097 targetLoc: '',
1098 expect: CONFLICT,
1099 expectSelf: REPLACE,
1100 })
1101
1102 // root -> (c@1||2, a@2)
1103 // a@1 -> PEER(b@1)
1104 // a@2 -> PEER(b@2)
1105 // b@1 -> PEER(c@1)
1106 // b@2 -> PEER(c@2)
1107 // c@1 -> PEER(d@1)
1108 // c@2 -> PEER(d@2)
1109 //
1110 // root
1111 // +-- a@1
1112 // +-- b@1
1113 // +-- c@1
1114 // +-- d@1
1115 //
1116 // place a@2 peerSet(b@2, c@2, d@2)
1117 //
1118 // peer group (c@1, d@1) can be replaced, because the entry node c has a
1119 // valid replacement.
1120
1121 runTest('have replacement for conflicted entry node', {
1122 tree: new Node({
1123 path,
1124 pkg: { dependencies: { a: '2', c: '1||2' } },
1125 children: [
1126 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { b: '1' } } },
1127 { pkg: { name: 'b', version: '1.0.0', peerDependencies: { c: '1' } } },
1128 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { d: '1' } } },
1129 { pkg: { name: 'd', version: '1.0.0' } },
1130 ],
1131 }),
1132 dep: new Node({
1133 pkg: { name: 'a', version: '2.0.0', peerDependencies: { b: '2' } },
1134 }),
1135 peerSet: [
1136 { pkg: { name: 'b', version: '2.0.0', peerDependencies: { c: '2' } } },
1137 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { d: '2' } } },
1138 { pkg: { name: 'd', version: '2.0.0' } },
1139 ],
1140 nodeLoc: '',
1141 targetLoc: '',
1142 expect: REPLACE,
1143 expectSelf: REPLACE,
1144 })
1145
1146 // v@4 -> PEER(a@1||2)
1147 // y@1 -> PEER(d@1)
1148 // a@1 -> PEER(b@1)
1149 // b@1 -> PEER(c@1)
1150 // c@1 -> PEER(d@1)
1151 // d@1 -> PEER(e@1)
1152 // e@1 -> PEER(a@1)
1153 // a@2 -> PEER(b@2)
1154 // b@2 -> PEER(c@2)
1155 // c@2 -> PEER(d@2)
1156 // d@2 -> PEER(e@2)
1157 // e@2 -> PEER(a@2)
1158 //
1159 // root
1160 // +-- v@4
1161 // +-- a@2
1162 // +-- b@2
1163 // +-- c@2
1164 // +-- d@2
1165 // +-- e@2
1166 //
1167 // place y@1 (a@1, b@1, c@1, d@1, e@1), OK, because all peers replaced
1168 runTest('replacing overlapping peer sets', {
1169 tree: new Node({
1170 path,
1171 pkg: { dependencies: { v: '4', y: '1' } },
1172 children: [
1173 {
1174 pkg: {
1175 name: 'v',
1176 version: '4.0.0',
1177 peerDependencies: { a: '1||2', x: '2' },
1178 peerDependenciesMeta: { x: { optional: true } },
1179 },
1180 },
1181 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { b: '2' } } },
1182 { pkg: { name: 'b', version: '2.0.0', peerDependencies: { c: '2' } } },
1183 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { d: '2' } } },
1184 { pkg: { name: 'd', version: '2.0.0', peerDependencies: { e: '2' } } },
1185 { pkg: { name: 'e', version: '2.0.0', peerDependencies: { a: '2' } } },
1186 ],
1187 }),
1188 dep: new Node({
1189 pkg: { name: 'y', version: '1.0.0', peerDependencies: { d: '1' } },
1190 }),
1191 peerSet: [
1192 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { b: '1' } } },
1193 { pkg: { name: 'b', version: '1.0.0', peerDependencies: { c: '1' } } },
1194 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { d: '1' } } },
1195 { pkg: { name: 'd', version: '1.0.0', peerDependencies: { e: '1' } } },
1196 { pkg: { name: 'e', version: '1.0.0', peerDependencies: { a: '1' } } },
1197 ],
1198 nodeLoc: '',
1199 targetLoc: '',
1200 expect: OK,
1201 })
1202
1203 // same as above, but the new peer set only overlaps _part_ of the existing
1204 // v@4 -> PEER(a@1||2)
1205 // y@1 -> PEER(d@1)
1206 // a@1 -> PEER(c@1)
1207 // c@1 -> PEER(e@1)
1208 // e@1 -> PEER(a@1)
1209 // a@2 -> PEER(b@2)
1210 // b@2 -> PEER(c@2)
1211 // c@2 -> PEER(d@2)
1212 // d@2 -> PEER(e@2)
1213 // e@2 -> PEER(a@2)
1214 //
1215 // root
1216 // +-- v@4
1217 // +-- a@2
1218 // +-- b@2
1219 // +-- c@2
1220 // +-- d@2
1221 // +-- e@2
1222 //
1223 // place y@1 (a@1, c@1, e@1), OK, because all peers replaced
1224 runTest('replacing partially overlapping peer sets, subset', {
1225 tree: new Node({
1226 path,
1227 pkg: { dependencies: { v: '4', y: '1' } },
1228 children: [
1229 {
1230 pkg: {
1231 name: 'v',
1232 version: '4.0.0',
1233 peerDependencies: { a: '1||2', x: '2' },
1234 peerDependenciesMeta: { x: { optional: true } },
1235 },
1236 },
1237 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { b: '2' } } },
1238 { pkg: { name: 'b', version: '2.0.0', peerDependencies: { c: '2' } } },
1239 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { d: '2' } } },
1240 { pkg: { name: 'd', version: '2.0.0', peerDependencies: { e: '2' } } },
1241 { pkg: { name: 'e', version: '2.0.0', peerDependencies: { a: '2' } } },
1242 ],
1243 }),
1244 dep: new Node({
1245 pkg: { name: 'y', version: '1.0.0', peerDependencies: { d: '1' } },
1246 }),
1247 peerSet: [
1248 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { c: '1' } } },
1249 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { e: '1' } } },
1250 { pkg: { name: 'e', version: '1.0.0', peerDependencies: { a: '1' } } },
1251 ],
1252 nodeLoc: '',
1253 targetLoc: '',
1254 expect: OK,
1255 })
1256
1257 // same as above, but now the existing one has 3, replacement has 5
1258 // v@4 -> PEER(a@1||2)
1259 // y@1 -> PEER(d@1)
1260 // a@1 -> PEER(b@1)
1261 // b@1 -> PEER(c@1)
1262 // c@1 -> PEER(d@1)
1263 // d@1 -> PEER(e@1)
1264 // e@1 -> PEER(a@1)
1265 // a@2 -> PEER(c@2)
1266 // c@2 -> PEER(e@2)
1267 // e@2 -> PEER(a@2)
1268 //
1269 // root
1270 // +-- v@4
1271 // +-- a@2
1272 // +-- c@2
1273 // +-- e@2
1274 //
1275 // place y@1 (a@1, b@1, c@1, d@1, e@1), OK, because all peers replaced
1276 runTest('replacing partially overlapping peer sets, superset', {
1277 tree: new Node({
1278 path,
1279 pkg: { dependencies: { v: '4', y: '1' } },
1280 children: [
1281 {
1282 pkg: {
1283 name: 'v',
1284 version: '4.0.0',
1285 peerDependencies: { a: '1||2', x: '2' },
1286 peerDependenciesMeta: { x: { optional: true } },
1287 },
1288 },
1289 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { c: '2' } } },
1290 { pkg: { name: 'c', version: '2.0.0', peerDependencies: { e: '2' } } },
1291 { pkg: { name: 'e', version: '2.0.0', peerDependencies: { a: '2' } } },
1292 ],
1293 }),
1294 dep: new Node({
1295 pkg: { name: 'y', version: '1.0.0', peerDependencies: { d: '1' } },
1296 }),
1297 peerSet: [
1298 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { b: '1' } } },
1299 { pkg: { name: 'b', version: '1.0.0', peerDependencies: { c: '1' } } },
1300 { pkg: { name: 'c', version: '1.0.0', peerDependencies: { d: '1' } } },
1301 { pkg: { name: 'd', version: '1.0.0', peerDependencies: { e: '1' } } },
1302 { pkg: { name: 'e', version: '1.0.0', peerDependencies: { a: '1' } } },
1303 ],
1304 nodeLoc: '',
1305 targetLoc: '',
1306 expect: OK,
1307 })
1308
1309 // partly overlapping peer sets that diverge
1310 // v -> PEER(a@1||2, x@1)
1311 // a@1 -> PEER(c@1, d@1)
1312 // a@2 -> PEER(c@2, e@1)
1313 // x@1 -> PEER(y@1)
1314 // y@1 -> PEER(a@1||2)
1315 // w -> PEER(a@1, j@1)
1316 // j@1 -> PEER(y@1)
1317 // root
1318 // +-- v
1319 // +-- a@2
1320 // +-- c@2
1321 // +-- e@1
1322 // +-- x@1
1323 // +-- y@1
1324 // place w(a@1, j@1, y@1, c@1, d@1), OK
1325 runTest('replacing partially overlapping divergent peer sets', {
1326 tree: new Node({
1327 path,
1328 pkg: { dependencies: { v: '', w: '' } },
1329 children: [
1330 {
1331 pkg: {
1332 name: 'v',
1333 version: '1.0.0',
1334 peerDependencies: { a: '1||2', x: '1' },
1335 },
1336 },
1337 { pkg: { name: 'a', version: '2.0.0', peerDependencies: { c: '2', e: '1' } } },
1338 { pkg: { name: 'c', version: '2.0.0' } },
1339 { pkg: { name: 'e', version: '1.0.0' } },
1340 { pkg: { name: 'x', version: '1.0.0', peerDependencies: { y: '1' } } },
1341 { pkg: { name: 'y', version: '1.0.0', peerDependencies: { a: '1||2' } } },
1342 ],
1343 }),
1344 dep: new Node({
1345 pkg: { name: 'w', version: '1.0.0', peerDependencies: { a: '1', j: '1' } },
1346 }),
1347 peerSet: [
1348 { pkg: { name: 'a', version: '1.0.0', peerDependencies: { c: '1', d: '1' } } },
1349 { pkg: { name: 'j', version: '1.0.0', peerDependencies: { y: '1' } } },
1350 { pkg: { name: 'y', version: '1.0.0', peerDependencies: { a: '1||2' } } },
1351 { pkg: { name: 'c', version: '1.0.0' } },
1352 { pkg: { name: 'd', version: '1.0.0' } },
1353 ],
1354 nodeLoc: '',
1355 targetLoc: '',
1356 expect: OK,
1357 })
1358
1359 // root -> (k, y@1)
1360 // k -> (x)
1361 // x -> PEER(y@1||2)
1362 //
1363 // root
1364 // +-- y@1
1365 // +-- k@1
1366 //
1367 // place x in root with y@2 in peerset
1368 // https://github.com/npm/cli/issues/3881
1369 runTest('can dedupe, cannot place peer', {
1370 tree: new Node({
1371 path,
1372 pkg: { dependencies: { k: '1', y: '1' } },
1373 children: [
1374 { pkg: { name: 'y', version: '1.0.0' } },
1375 { pkg: { name: 'k', version: '1.0.0', dependencies: { x: '' } } },
1376 ],
1377 }),
1378 dep: new Node({
1379 pkg: { name: 'x', version: '1.0.0', peerDependencies: { y: '1||2' } },
1380 }),
1381 peerSet: [
1382 { pkg: { name: 'y', version: '2.0.0' } },
1383 ],
1384 targetLoc: '',
1385 nodeLoc: 'node_modules/k',
1386 expect: OK,
1387 })
1388
1389 t.end()
1390 })
1391
1392 t.test('constructor debug throws', t => {
1393 t.throws(() => new CanPlaceDep({}), {
1394 message: 'no dep provided to CanPlaceDep',
1395 })
1396
1397 t.throws(() => new CanPlaceDep({
1398 dep: new Node({ pkg: { name: 'x', version: '1.2.3' } }),
1399 }), {
1400 message: 'no target provided to CanPlaceDep',
1401 })
1402
1403 t.throws(() => new CanPlaceDep({
1404 dep: new Node({ pkg: { name: 'x', version: '1.2.3' } }),
1405 target: new Node({ path: '/some/path' }),
1406 }), {
1407 message: 'no edge provided to CanPlaceDep',
1408 })
1409
1410 t.end()
1411 })