Debian Codegraph @

workspaces/arborist/test/edge.js

raw
1 const util = require('node:util')
2 const Edge = require('../lib/edge.js')
3 const OverrideSet = require('../lib/override-set.js')
4 const t = require('tap')
5
6 // slight hack to snapshot the getters
7 // would be nice if tcompare.format showed these by default,
8 // but it's tricky to know when to show non-iterables and
9 // when not to. Really, it'd be best if class getters were
10 // iterable by default, or had some syntax to allow it, but
11 // that's outside my sphere of direct influence, and using
12 // Object.defineProperty(this, 'foo', { get ... }) is a pita.
13 t.formatSnapshot = obj =>
14 obj instanceof Edge ? {
15 ...obj,
16 spec: obj.spec,
17 name: obj.name,
18 type: obj.type,
19 valid: obj.valid,
20 error: obj.error,
21 from: obj.from,
22 to: obj.to,
23 peer: obj.peer,
24 dev: obj.dev,
25 optional: obj.optional,
26 workspace: obj.workspace,
27 missing: obj.missing,
28 peerLocal: obj.peerLocal,
29 invalid: obj.invalid,
30 __proto__: { constructor: Edge },
31 } : obj
32
33 const reset = node => {
34 node.edgesOut = new Map()
35 node.edgesIn = new Set()
36 }
37
38 // mock nodes
39 const top = {
40 name: 'top',
41 packageName: 'top',
42 edgesOut: new Map(),
43 edgesIn: new Set(),
44 explain: () => 'top node explanation',
45 package: { name: 'top', version: '1.2.3' },
46 get version () {
47 return this.package.version
48 },
49 isTop: true,
50 parent: null,
51 resolve (n) {
52 return n === 'a' ? a : n === 'b' ? b : null
53 },
54 addEdgeOut (edge) {
55 this.edgesOut.set(edge.name, edge)
56 },
57 addEdgeIn (edge) {
58 this.edgesIn.add(edge)
59 },
60 deleteEdgeIn (edge) {
61 this.edgesIn.delete(edge)
62 },
63 }
64
65 const a = {
66 name: 'a',
67 packageName: 'a',
68 edgesOut: new Map(),
69 edgesIn: new Set(),
70 explain: () => 'a explanation',
71 package: { name: 'a', version: '1.2.3' },
72 get version () {
73 return this.package.version
74 },
75 isTop: false,
76 parent: top,
77 root: top,
78 resolve (n) {
79 return n === 'aa' ? aa : this.parent.resolve(n)
80 },
81 addEdgeOut (edge) {
82 this.edgesOut.set(edge.name, edge)
83 },
84 addEdgeIn (edge) {
85 this.edgesIn.add(edge)
86 },
87 deleteEdgeIn (edge) {
88 this.edgesIn.delete(edge)
89 },
90 }
91
92 const b = {
93 name: 'b',
94 packageName: 'b',
95 edgesOut: new Map(),
96 edgesIn: new Set(),
97 explain: () => 'b explanation',
98 package: { name: 'b', version: '1.2.3' },
99 get version () {
100 return this.package.version
101 },
102 isTop: false,
103 parent: top,
104 resolve (n) {
105 return n === 'aa' ? aa : this.parent.resolve(n)
106 },
107 addEdgeOut (edge) {
108 this.edgesOut.set(edge.name, edge)
109 },
110 addEdgeIn (edge) {
111 this.edgesIn.add(edge)
112 },
113 deleteEdgeIn (edge) {
114 this.edgesIn.delete(edge)
115 },
116 }
117
118 const bb = {
119 name: 'b',
120 packageName: 'bb',
121 edgesOut: new Map(),
122 edgesIn: new Set(),
123 explain: () => 'bb explanation',
124 package: { name: 'bb', version: '1.2.3' },
125 get version () {
126 return this.package.version
127 },
128 isTop: false,
129 parent: b,
130 resolve (n) {
131 return this.parent.resolve(n)
132 },
133 addEdgeOut (edge) {
134 this.edgesOut.set(edge.name, edge)
135 },
136 addEdgeIn (edge) {
137 this.edgesIn.add(edge)
138 },
139 deleteEdgeIn (edge) {
140 this.edgesIn.delete(edge)
141 },
142 }
143
144 const aa = {
145 name: 'aa',
146 packageName: 'aa',
147 edgesOut: new Map(),
148 edgesIn: new Set(),
149 explain: () => 'aa explanation',
150 package: { name: 'aa', version: '1.2.3' },
151 get version () {
152 return this.package.version
153 },
154 isTop: false,
155 parent: a,
156 resolve (n) {
157 return this.parent.resolve(n)
158 },
159 addEdgeOut (edge) {
160 this.edgesOut.set(edge.name, edge)
161 },
162 addEdgeIn (edge) {
163 this.edgesIn.add(edge)
164 },
165 deleteEdgeIn (edge) {
166 this.edgesIn.delete(edge)
167 },
168 }
169
170 const c = {
171 name: 'c',
172 packageName: 'c',
173 edgesOut: new Map(),
174 edgesIn: new Set(),
175 explain: () => 'c explanation',
176 package: { name: 'c', version: '2.3.4' },
177 get version () {
178 return this.package.version
179 },
180 isTop: false,
181 parent: top,
182 resolve (n) {
183 return this.parent.resolve(n)
184 },
185 addEdgeOut (edge) {
186 this.edgesOut.set(edge.name, edge)
187 },
188 addEdgeIn (edge) {
189 this.edgesIn.add(edge)
190 },
191 deleteEdgeIn (edge) {
192 this.edgesIn.delete(edge)
193 },
194 }
195
196 t.matchSnapshot(new Edge({
197 from: top,
198 type: 'peer',
199 name: 'a',
200 spec: '1.2.3',
201 }), 'peer dep at top level, nesting allowed')
202 reset(top)
203 reset(a)
204
205 t.matchSnapshot(new Edge({
206 from: top,
207 type: 'optional',
208 name: 'missing',
209 spec: '',
210 }), 'missing optional dep is fine')
211 reset(a)
212
213 t.matchSnapshot(new Edge({
214 from: a,
215 type: 'peer',
216 name: 'aa',
217 spec: '1.2.3',
218 }), 'peer dep below top level, nesting disallowed')
219 reset(a)
220 reset(aa)
221
222 t.matchSnapshot(new Edge({
223 from: a,
224 type: 'peer',
225 name: 'b',
226 spec: '1.2.3',
227 }), 'peer dep below top level, parallel allowed')
228 reset(a)
229 reset(b)
230
231 t.ok(new Edge({
232 from: a,
233 type: 'prod',
234 name: 'b',
235 spec: '1.x',
236 }).satisfiedBy(b), 'b satisfies [email protected]')
237 reset(a)
238 reset(b)
239
240 t.ok(new Edge({
241 from: a,
242 type: 'prod',
243 name: 'c',
244 spec: '1.x',
245 accept: '2.x',
246 }).satisfiedBy(c), 'c@2 satisfies spec:1.x, accept:2.x')
247 reset(a)
248
249 t.equal(
250 (new Edge({
251 from: a,
252 type: 'prod',
253 name: 'c',
254 spec: '1.x',
255 accept: '2.x',
256 })).accept, '2.x', '.accept getter works')
257 reset(a)
258
259 t.ok(new Edge({
260 from: a,
261 type: 'prod',
262 name: 'c',
263 spec: '1.x',
264 accept: '',
265 }).satisfiedBy(c), 'c@2 satisfies spec:1.x, accept:*')
266 reset(a)
267
268 t.not(new Edge({
269 from: a,
270 type: 'prod',
271 name: 'c',
272 spec: '1.x',
273 }).satisfiedBy(b), 'b does not satisfy edge for c')
274 reset(a)
275
276 const overrideSet = new OverrideSet({
277 overrides: {
278 c: '2.x',
279 },
280 })
281
282 a.overrides = overrideSet
283 t.matchSnapshot(new Edge({
284 from: a,
285 type: 'prod',
286 name: 'c',
287 spec: '1.x',
288 overrides: overrideSet.getEdgeRule({ name: 'c', spec: '1.x' }),
289 }).toJSON(), 'printableEdge shows overrides')
290 reset(a)
291
292 const overriddenExplanation = new Edge({
293 from: a,
294 type: 'prod',
295 name: 'c',
296 spec: '1.x',
297 overrides: overrideSet.getEdgeRule({ name: 'c', spec: '1.x' }),
298 }).explain()
299 t.equal(overriddenExplanation.rawSpec, '1.x', 'rawSpec has original spec')
300 t.equal(overriddenExplanation.spec, '2.x', 'spec has override spec')
301 t.equal(overriddenExplanation.overridden, true, 'overridden is set to true')
302 reset(a)
303
304 t.ok(new Edge({
305 from: a,
306 type: 'prod',
307 name: 'c',
308 spec: '1.x',
309 overrides: overrideSet.getEdgeRule({ name: 'c', spec: '1.x' }),
310 }).satisfiedBy(c), 'c@2 satisfies spec:1.x, override:2.x')
311 reset(a)
312
313 const overrideSetB = new OverrideSet({
314 overrides: {
315 b: '1.x',
316 },
317 })
318 a.overrides = overrideSetB
319 t.matchSnapshot(new Edge({
320 from: a,
321 type: 'prod',
322 name: 'c',
323 spec: '2.x',
324 overrides: overrideSetB.getEdgeRule({ name: 'c', spec: '2.x' }),
325 }).toJSON(), 'printableEdge does not show non-applicable override')
326
327 t.ok(new Edge({
328 from: a,
329 type: 'prod',
330 name: 'c',
331 spec: '2.x',
332 overrides: overrideSetB.getEdgeRule({ name: 'c', spec: '2.x' }),
333 }).satisfiedBy(c), 'c@2 satisfies spec:1.x, no matching override')
334 reset(a)
335 delete a.overrides
336
337 const overrideEdge = new Edge({
338 from: a,
339 type: 'prod',
340 name: 'c',
341 spec: '2.x',
342 })
343 t.notOk(overrideEdge.overrides, 'edge has no overrides')
344 a.overrides = new OverrideSet({ overrides: { b: '1.x' } })
345 t.notOk(overrideEdge.overrides, 'edge has no overrides')
346 overrideEdge.reload()
347 t.ok(overrideEdge.overrides, 'edge has overrides after reload')
348 delete a.overrides
349 overrideEdge.reload()
350 t.notOk(overrideEdge.overrides, 'edge has no overrides after reload')
351 reset(a)
352
353 const referenceTop = {
354 name: 'referenceTop',
355 packageName: 'referenceTop',
356 edgesOut: new Map(),
357 edgesIn: new Set(),
358 explain: () => 'referenceTop explanation',
359 package: {
360 name: 'referenceTop',
361 version: '1.2.3',
362 dependencies: {
363 referenceChild: '^1.0.0',
364 },
365 overrides: {
366 referenceGrandchild: '$referenceChild',
367 },
368 },
369 get version () {
370 return this.package.version
371 },
372 isTop: true,
373 resolve (n) {
374 return n === 'referenceChild'
375 ? referenceChild : n === 'referenceGrandchild'
376 ? referenceGrandchild : null
377 },
378 addEdgeOut (edge) {
379 edge.overrides = this.overrides.getEdgeRule(edge)
380 this.edgesOut.set(edge.name, edge)
381 },
382 addEdgeIn (edge) {
383 this.edgesIn.add(edge)
384 },
385 deleteEdgeIn (edge) {
386 this.edgesIn.delete(edge)
387 },
388 overrides: new OverrideSet({
389 overrides: {
390 referenceGrandchild: '$referenceChild',
391 },
392 }),
393 }
394
395 const referenceChild = {
396 name: 'referenceChild',
397 packageName: 'referenceChild',
398 edgesOut: new Map(),
399 edgesIn: new Set(),
400 explain: () => 'referenceChild explanation',
401 package: {
402 name: 'referenceChild',
403 version: '1.2.3',
404 dependencies: {
405 referenceGrandchild: '^2.0.0',
406 },
407 },
408 get version () {
409 return this.package.version
410 },
411 isTop: false,
412 parent: referenceTop,
413 root: referenceTop,
414 resolve (n) {
415 return n === 'referenceChild'
416 ? referenceChild : n === 'referenceGrandchild'
417 ? referenceGrandchild : null
418 },
419 addEdgeOut (edge) {
420 edge.overrides = this.overrides.getEdgeRule(edge)
421 this.edgesOut.set(edge.name, edge)
422 },
423 addEdgeIn (edge) {
424 this.overrides = edge.overrides
425 this.edgesIn.add(edge)
426 },
427 deleteEdgeIn (edge) {
428 this.edgesIn.delete(edge)
429 },
430 }
431
432 new Edge({
433 from: referenceTop,
434 to: referenceChild,
435 type: 'prod',
436 name: 'referenceChild',
437 spec: '^1.0.0',
438 })
439
440 const referenceGrandchild = {
441 name: 'referenceGrandchild',
442 packageName: 'referenceGrandchild',
443 edgesOut: new Map(),
444 edgesIn: new Set(),
445 explain: () => 'referenceGrandchild explanation',
446 package: {
447 name: 'referenceGrandchild',
448 version: '1.2.3',
449 },
450 get version () {
451 return this.package.version
452 },
453 isTop: false,
454 parent: referenceChild,
455 root: referenceTop,
456 resolve (n) {
457 return n === 'referenceChild'
458 ? referenceChild : n === 'referenceGrandchild'
459 ? referenceGrandchild : null
460 },
461 addEdgeOut (edge) {
462 edge.overrides = this.overrides.getEdgeRule(edge)
463 this.edgesOut.set(edge.name, edge)
464 },
465 addEdgeIn (edge) {
466 this.overrides = edge.overrides
467 this.edgesIn.add(edge)
468 },
469 deleteEdgeIn (edge) {
470 this.edgesIn.delete(edge)
471 },
472 }
473
474 const referenceGrandchildEdge = new Edge({
475 from: referenceChild,
476 to: referenceGrandchild,
477 type: 'prod',
478 name: 'referenceGrandchild',
479 spec: '^2.0.0',
480 })
481
482 t.equal(referenceGrandchildEdge.spec, '^1.0.0', 'resolves spec to prod dep')
483 t.equal(referenceGrandchildEdge.valid, true, 'edge is valid')
484
485 delete referenceTop.package.dependencies.referenceChild
486 t.throws(() => referenceGrandchildEdge.spec, 'spec getter throws for missing dep')
487
488 referenceTop.package.devDependencies = { referenceChild: '^2.0.0' }
489 t.equal(referenceGrandchildEdge.spec, '^2.0.0', 'resolves spec for dev dep')
490
491 delete referenceTop.package.devDependencies
492 referenceTop.package.optionalDependencies = { referenceChild: '^3.0.0' }
493 t.equal(referenceGrandchildEdge.spec, '^3.0.0', 'resolves spec for optional dep')
494
495 delete referenceTop.package.optionalDependencies
496 referenceTop.package.peerDependencies = { referenceChild: '^4.0.0' }
497 t.equal(referenceGrandchildEdge.spec, '^4.0.0', 'resolves spec for peer dep')
498
499 const badOverride = {
500 name: 'c',
501 packageName: 'c',
502 edgesOut: new Map(),
503 edgesIn: new Set(),
504 explain: () => 'c explanation',
505 package: { name: 'c', version: '2.3.4' },
506 get version () {
507 return this.package.version
508 },
509 isTop: false,
510 parent: top,
511 resolve (n) {
512 return this.parent.resolve(n)
513 },
514 addEdgeOut (edge) {
515 this.edgesOut.set(edge.name, edge)
516 },
517 addEdgeIn (edge) {
518 this.edgesIn.add(edge)
519 },
520 deleteEdgeIn (edge) {
521 this.edgesIn.delete(edge)
522 },
523 overrides: new OverrideSet({
524 overrides: {
525 b: '1.x',
526 },
527 }),
528 }
529
530 t.not(new Edge({
531 from: a,
532 type: 'prod',
533 name: 'c',
534 spec: '2.x',
535 overrides: new OverrideSet({
536 overrides: {
537 b: '1.x',
538 },
539 }),
540 }).satisfiedBy(badOverride), 'node with different override fails')
541 reset(a)
542
543 const overrides = new OverrideSet({
544 overrides: {
545 c: '1.x',
546 },
547 })
548 a.overrides = overrides
549 const overriddenEdge = new Edge({
550 from: a,
551 type: 'prod',
552 name: 'c',
553 spec: '2.x',
554 overrides: overrides.getEdgeRule({ name: 'c', spec: '2.x' }),
555 })
556 t.equal(overriddenEdge.spec, '1.x', 'override spec takes priority')
557 t.equal(overriddenEdge.rawSpec, '2.x', 'rawSpec holds original spec')
558 reset(a)
559 delete a.overrides
560
561 const old = new Edge({
562 from: a,
563 type: 'peer',
564 name: 'b',
565 spec: '1.2.3',
566 })
567 const neu = new Edge({
568 from: a,
569 type: 'prod',
570 name: 'b',
571 spec: '*',
572 })
573 t.matchSnapshot(old, 'clobbered edge')
574 t.matchSnapshot(neu, 'clobbering edge')
575
576 reset(a)
577 reset(b)
578
579 const abInvalid = new Edge({
580 from: a,
581 name: 'b',
582 spec: '1.69.420-nice',
583 type: 'optional',
584 })
585 t.matchSnapshot(abInvalid, 'invalid dependency')
586 // make it valid, and then reload
587 b.package.version = '1.69.420-nice'
588 abInvalid.reload(true)
589 t.equal(abInvalid.valid, true, 'valid after updating target and hard reload')
590 // put it back for other tests
591 b.package.version = '1.2.3'
592
593 const moving = new Edge({
594 from: bb,
595 name: 'aa',
596 spec: '',
597 type: 'prod',
598 })
599 const explBeforeMove = moving.explain()
600 t.matchSnapshot(moving, 'old location, missing dep')
601 bb.parent = a
602 moving.reload()
603 const explAfterMove = moving.explain()
604 t.not(explBeforeMove, explAfterMove, 'moving reloads the explanation')
605 t.matchSnapshot(moving, 'new location, found dep')
606 bb.parent = top
607 moving.reload()
608 t.matchSnapshot(moving, 'new location, missing dep again')
609 new Edge({
610 from: bb,
611 name: 'aa',
612 spec: '*',
613 type: 'dev',
614 })
615 t.matchSnapshot(moving, 'clobbered and detached')
616
617 t.throws(() => new Edge({
618 from: top,
619 type: 'prod',
620 name: 'yoinks',
621 spec: { yoinks: '1.2.3' },
622 }), new TypeError('must provide string spec'))
623
624 t.throws(() => new Edge({
625 from: top,
626 type: 'prod',
627 name: 'yoinks',
628 spec: '1.x',
629 accept: { yoinks: '2.2.3' },
630 }), new TypeError('accept field must be a string if provided'))
631
632 t.throws(() => new Edge({
633 from: top,
634 type: 'not a valid type',
635 name: 'yoinks',
636 spec: '*',
637 }), new TypeError('invalid type: not a valid type\n(valid types are: '))
638
639 t.throws(() => new Edge({
640 type: 'prod',
641 spec: '*',
642 from: top,
643 }), new TypeError('must provide dependency name'))
644
645 t.throws(() => new Edge({
646 type: 'prod',
647 name: 'foo',
648 spec: '',
649 }), new TypeError('must provide "from" node'))
650
651 t.throws(() => new Edge({
652 type: 'workspace',
653 name: 'foo',
654 spec: '*',
655 }), new TypeError('workspace edges must be a symlink'))
656
657 t.test('convenience type getter flags', async t => {
658 t.equal(new Edge({
659 from: a,
660 type: 'workspace',
661 name: 'foo',
662 spec: 'file:bar/baz',
663 }).workspace, true, 'workspace convenience getter')
664
665 t.equal(new Edge({
666 from: a,
667 type: 'prod',
668 name: 'foo',
669 spec: '*',
670 }).prod, true, 'prod convenience getter')
671
672 t.equal(new Edge({
673 from: a,
674 type: 'dev',
675 name: 'foo',
676 spec: '*',
677 }).dev, true, 'dev convenience getter')
678
679 t.equal(new Edge({
680 from: a,
681 type: 'optional',
682 name: 'foo',
683 spec: '*',
684 }).optional, true, 'optional convenience getter')
685
686 t.equal(new Edge({
687 from: a,
688 type: 'peer',
689 name: 'foo',
690 spec: '*',
691 }).peer, true, 'peer convenience getter')
692
693 t.equal(new Edge({
694 from: a,
695 type: 'optional',
696 name: 'foo',
697 spec: '*',
698 }).optional, true, 'optional convenience getter')
699
700 t.equal(new Edge({
701 from: a,
702 type: 'peerOptional',
703 name: 'foo',
704 spec: '*',
705 }).peer, true, 'peer convenience getter for peerOptional edge')
706
707 t.equal(new Edge({
708 from: a,
709 type: 'peerOptional',
710 name: 'foo',
711 spec: '*',
712 }).optional, true, 'optional convenience getter for peerOptional edge')
713
714 const explainEdge = new Edge({
715 from: a,
716 type: 'peerOptional',
717 name: 'foo',
718 spec: '*',
719 })
720 const expl = explainEdge.explain([])
721 t.equal(explainEdge.explain(), expl)
722 t.matchSnapshot(expl, 'explanation')
723 explainEdge.detach()
724 t.not(explainEdge.explain(), expl)
725 })
726
727 // FIXME: once we drop support to node10 we can remove this
728 const normalizeNode10compatSnapshots = str =>
729 str
730 .replace(/\n +/g, '\n')
731 .replace(/\n\}/g, ' }')
732 .replace(/ArboristEdge /g, '')
733
734 const printableTo = {
735 ...b,
736 location: '/node_modules/b',
737 }
738 const printableFrom = {
739 ...a,
740 resolve () {
741 return printableTo
742 },
743 location: '',
744 }
745 const printable = new Edge({
746 from: printableFrom,
747 type: 'prod',
748 name: 'b',
749 spec: '1.2.3',
750 })
751 t.matchSnapshot(
752 normalizeNode10compatSnapshots(
753 util.inspect(printable)
754 ),
755 'should return a human-readable representation of the edge obj'
756 )
757 printable.peerConflicted = true
758 t.matchSnapshot(
759 normalizeNode10compatSnapshots(
760 util.inspect(printable)
761 ),
762 'return a human-readable representation of the edge obj, peerConflicted=true'
763 )
764
765 const minimalPrintableFrom = {
766 ...a,
767 resolve () {
768 return null
769 },
770 }
771 const minimalPrintable = new Edge({
772 from: minimalPrintableFrom,
773 type: 'dev',
774 name: 'b',
775 spec: '1.2.3',
776 })
777 t.match(
778 minimalPrintable.toJSON(),
779 {
780 name: 'b',
781 spec: '1.2.3',
782 type: 'dev',
783 error: 'MISSING',
784 },
785 'should return a minimal human-readable representation of the edge obj'
786 )
787
788 const bundleChild = {
789 name: 'bundle-child',
790 edgesOut: new Map(),
791 edgesIn: new Set(),
792 explain: () => 'bundleChild explanation',
793 package: { name: 'bundle-child', version: '1.2.3' },
794 get version () {
795 return this.package.version
796 },
797 isTop: false,
798 parent: top,
799 resolve (n) {
800 return this.parent.resolve(n)
801 },
802 addEdgeOut (edge) {
803 this.edgesOut.set(edge.name, edge)
804 },
805 addEdgeIn (edge) {
806 this.edgesIn.add(edge)
807 },
808 deleteEdgeIn (edge) {
809 this.edgesIn.delete(edge)
810 },
811 }
812
813 const bundleParent = {
814 name: 'bundle-parent',
815 edgesOut: new Map(),
816 edgesIn: new Set(),
817 explain: () => 'bundleParent explanation',
818 package: { name: 'bundle-parent', version: '5.6.7', bundleDependencies: ['bundle-child'] },
819 get version () {
820 return this.package.version
821 },
822 isTop: false,
823 parent: top,
824 resolve (n) {
825 return n === 'bundle-child' ? bundleChild : undefined
826 },
827 addEdgeOut (edge) {
828 this.edgesOut.set(edge.name, edge)
829 },
830 addEdgeIn (edge) {
831 this.edgesIn.add(edge)
832 },
833 deleteEdgeIn (edge) {
834 this.edgesIn.delete(edge)
835 },
836 }
837
838 const bundledEdge = new Edge({
839 from: bundleParent,
840 type: 'prod',
841 name: 'bundle-child',
842 spec: '1.2.3',
843 })
844
845 t.ok(bundledEdge.satisfiedBy(bundleChild), 'bundled dependency')
846 const fromBundleDependencies = bundledEdge.from &&
847 bundledEdge.from.package.bundleDependencies
848 t.same(fromBundleDependencies, ['bundle-child'], 'edge.from bundledDependencies as expected')
849 t.same(bundledEdge.name, 'bundle-child', 'edge name as expected')
850 t.equal(bundledEdge.bundled, true, 'bundled prop is true')
851 t.same(bundledEdge.explain(), {
852 type: 'prod',
853 name: 'bundle-child',
854 spec: '1.2.3',
855 bundled: true,
856 from: bundleParent.explain(),
857 }, 'bundled edge.explain as expected')
858
859 t.test('override references find the correct root', (t) => {
860 const overrides = new OverrideSet({
861 overrides: {
862 foo: '$foo',
863 },
864 })
865
866 const root = {
867 name: 'root',
868 packageName: 'root',
869 edgesOut: new Map(),
870 edgesIn: new Set(),
871 explain: () => 'root node explanation',
872 package: {
873 name: 'root',
874 version: '1.2.3',
875 dependencies: {
876 foo: '^1.0.0',
877 },
878 overrides: {
879 foo: '$foo',
880 },
881 },
882 get version () {
883 return this.package.version
884 },
885 isTop: true,
886 parent: null,
887 overrides,
888 resolve (n) {
889 return n === 'foo' ? foo : null
890 },
891 addEdgeOut (edge) {
892 this.edgesOut.set(edge.name, edge)
893 },
894 addEdgeIn (edge) {
895 this.edgesIn.add(edge)
896 },
897 deleteEdgeIn (edge) {
898 this.edgesIn.delete(edge)
899 },
900 }
901
902 const foo = {
903 name: 'foo',
904 packageName: 'foo',
905 edgesOut: new Map(),
906 edgesIn: new Set(),
907 explain: () => 'foo node explanation',
908 package: {
909 name: 'foo',
910 version: '1.2.3',
911 dependencies: {},
912 },
913 get version () {
914 return this.package.version
915 },
916 parent: root,
917 root: root,
918 resolve (n) {
919 return n === 'bar' ? bar : this.parent.resolve(n)
920 },
921 addEdgeOut (edge) {
922 this.edgesOut.set(edge.name, edge)
923 },
924 addEdgeIn (edge) {
925 this.edgesIn.add(edge)
926 },
927 deleteEdgeIn (edge) {
928 this.edgesIn.delete(edge)
929 },
930 }
931 foo.overrides = overrides.getNodeRule(foo)
932
933 const bar = {
934 name: 'bar',
935 packageName: 'bar',
936 edgesOut: new Map(),
937 edgesIn: new Set(),
938 explain: () => 'bar node explanation',
939 package: {
940 name: 'bar',
941 version: '1.2.3',
942 dependencies: {
943 foo: '^2.0.0',
944 },
945 },
946 get version () {
947 return this.package.version
948 },
949 parent: foo,
950 root: root,
951 resolve (n) {
952 return this.parent.resolve(n)
953 },
954 addEdgeOut (edge) {
955 this.edgesOut.set(edge.name, edge)
956 },
957 addEdgeIn (edge) {
958 this.edgesIn.add(edge)
959 },
960 deleteEdgeIn (edge) {
961 this.edgesIn.delete(edge)
962 },
963 }
964 bar.overrides = foo.overrides.getNodeRule(bar)
965
966 const virtualBar = {
967 name: 'bar',
968 packageName: 'bar',
969 edgesOut: new Map(),
970 edgesIn: new Set(),
971 explain: () => 'bar node explanation',
972 package: {
973 name: 'bar',
974 version: '1.2.3',
975 dependencies: {
976 foo: '^2.0.0',
977 },
978 },
979 parent: null,
980 root: null,
981 sourceReference: bar,
982 get version () {
983 return this.package.version
984 },
985 resolve (n) {
986 return bar.resolve(n)
987 },
988 addEdgeOut (edge) {
989 this.edgesOut.set(edge.name, edge)
990 },
991 addEdgeIn (edge) {
992 this.edgesIn.add(edge)
993 },
994 deleteEdgeIn (edge) {
995 this.edgesIn.delete(edge)
996 },
997 }
998 virtualBar.overrides = overrides
999
1000 const edge = new Edge({
1001 from: virtualBar,
1002 type: 'prod',
1003 spec: '^2.0.0',
1004 name: 'foo',
1005 overrides: overrides.getEdgeRule({ name: 'foo', spec: '^2.0.0' }),
1006 })
1007
1008 t.ok(edge.valid, 'edge is valid')
1009 t.end()
1010 })
1011
1012 t.test('shrinkwrapped and bundled deps are not overridden and remain valid', (t) => {
1013 const overrides = new OverrideSet({
1014 overrides: {
1015 bar: '^2.0.0',
1016 },
1017 })
1018
1019 const root = {
1020 name: 'root',
1021 packageName: 'root',
1022 edgesOut: new Map(),
1023 edgesIn: new Set(),
1024 explain: () => 'root node explanation',
1025 package: {
1026 name: 'root',
1027 version: '1.2.3',
1028 dependencies: {
1029 foo: '^1.0.0',
1030 },
1031 overrides: {
1032 bar: '^2.0.0',
1033 },
1034 },
1035 get version () {
1036 return this.package.version
1037 },
1038 isTop: true,
1039 parent: null,
1040 overrides,
1041 resolve (n) {
1042 return n === 'foo' ? foo : null
1043 },
1044 addEdgeOut (edge) {
1045 this.edgesOut.set(edge.name, edge)
1046 },
1047 addEdgeIn (edge) {
1048 this.edgesIn.add(edge)
1049 },
1050 deleteEdgeIn (edge) {
1051 this.edgesIn.delete(edge)
1052 },
1053 }
1054
1055 const foo = {
1056 name: 'foo',
1057 packageName: 'foo',
1058 edgesOut: new Map(),
1059 edgesIn: new Set(),
1060 explain: () => 'foo node explanation',
1061 hasShrinkwrap: true,
1062 package: {
1063 name: 'foo',
1064 version: '1.2.3',
1065 dependencies: {
1066 bar: '^1.0.0',
1067 },
1068 },
1069 get version () {
1070 return this.package.version
1071 },
1072 parent: root,
1073 root,
1074 resolve (n) {
1075 return n === 'bar' ? bar : this.parent.resolve(n)
1076 },
1077 addEdgeOut (edge) {
1078 this.edgesOut.set(edge.name, edge)
1079 },
1080 addEdgeIn (edge) {
1081 this.edgesIn.add(edge)
1082 },
1083 deleteEdgeIn (edge) {
1084 this.edgesIn.delete(edge)
1085 },
1086 }
1087 foo.overrides = overrides.getNodeRule(foo)
1088
1089 const bar = {
1090 name: 'bar',
1091 packageName: 'bar',
1092 edgesOut: new Map(),
1093 edgesIn: new Set(),
1094 explain: () => 'bar node explanation',
1095 inShrinkwrap: true,
1096 package: {
1097 name: 'bar',
1098 version: '1.2.3',
1099 dependencies: {},
1100 },
1101 get version () {
1102 return this.package.version
1103 },
1104 parent: foo,
1105 root,
1106 resolve (n) {
1107 return this.parent.resolve(n)
1108 },
1109 addEdgeOut (edge) {
1110 this.edgesOut.set(edge.name, edge)
1111 },
1112 addEdgeIn (edge) {
1113 this.edgesIn.add(edge)
1114 },
1115 deleteEdgeIn (edge) {
1116 this.edgesIn.delete(edge)
1117 },
1118 }
1119 bar.overrides = foo.overrides.getNodeRule(bar)
1120
1121 const edge = new Edge({
1122 from: foo,
1123 type: 'prod',
1124 spec: '^1.0.0',
1125 name: 'bar',
1126 overrides: overrides.getEdgeRule({ name: 'bar', spec: '^1.0.0' }),
1127 })
1128
1129 t.ok(edge.valid, 'edge is valid')
1130 t.end()
1131 })
1132
1133 t.test('overrideset comparison logic', (t) => {
1134 const overrides1 = new OverrideSet({
1135 overrides: {
1136 bar: '^2.0.0',
1137 },
1138 })
1139
1140 const overrides2 = new OverrideSet({
1141 overrides: {
1142 bar: '^2.0.0',
1143 },
1144 })
1145
1146 const overrides3 = new OverrideSet({
1147 overrides: {
1148 foo: '^2.0.0',
1149 },
1150 })
1151
1152 const overrides4 = new OverrideSet({
1153 overrides: {
1154 foo: '^1.0.0',
1155 },
1156 })
1157
1158 const overrides5 = new OverrideSet({
1159 overrides: {
1160 bar: '^2.0.0',
1161 foo: '^2.0.0',
1162 },
1163 })
1164
1165 const overrides6 = new OverrideSet({
1166 overrides: {
1167 },
1168 })
1169
1170 const overrides7 = new OverrideSet({
1171 overrides: {
1172 bar: {
1173 '.': '^2.0.0',
1174 baz: '1.2.3',
1175 },
1176 },
1177 })
1178
1179 t.ok(overrides1.isEqual(overrides1), 'overridesets are equal')
1180 t.ok(overrides1.isEqual(overrides2), 'overridesets are equal')
1181 t.ok(!overrides1.isEqual(overrides3), 'overridesets are different')
1182 t.ok(!overrides1.isEqual(overrides5), 'overridesets are different')
1183 t.ok(!overrides1.isEqual(overrides6), 'overridesets are different')
1184 t.ok(!overrides1.isEqual(overrides7), 'overridesets are different')
1185 t.ok(!overrides3.isEqual(overrides1), 'overridesets are different')
1186 t.ok(!overrides3.isEqual(overrides4), 'overridesets are different')
1187 t.ok(!overrides3.isEqual(overrides5), 'overridesets are different')
1188 t.ok(!overrides4.isEqual(overrides5), 'overridesets are different')
1189 t.ok(!overrides5.isEqual(overrides1), 'overridesets are different')
1190 t.ok(!overrides5.isEqual(overrides3), 'overridesets are different')
1191 t.ok(!overrides5.isEqual(overrides6), 'overridesets are different')
1192 t.ok(!overrides6.isEqual(overrides1), 'overridesets are different')
1193 t.ok(!overrides6.isEqual(overrides3), 'overridesets are different')
1194 t.ok(overrides6.isEqual(overrides6), 'overridesets are equal')
1195 t.ok(!overrides7.isEqual(overrides1), 'overridesets are different')
1196 t.end()
1197 })
1198
1199 t.test('override fallback to local when root missing dependency with from.overrides set', t => {
1200 const localFrom = {
1201 package: {
1202 devDependencies: {
1203 foo: '^1.2.3',
1204 },
1205 },
1206 root: {
1207 package: {
1208 // no 'foo' defined here
1209 },
1210 },
1211 edgesOut: new Map(),
1212 edgesIn: new Set(),
1213 // dummy overrides object that returns an override with isEqual defined
1214 overrides: {
1215 getEdgeRule (edge) {
1216 return {
1217 value: edge.overrides.value,
1218 name: edge.overrides.name,
1219 isEqual (other) {
1220 return other && this.value === other.value && this.name === other.name
1221 },
1222 }
1223 },
1224 },
1225 addEdgeOut (edge) {
1226 this.edgesOut.set(edge.name, edge)
1227 },
1228 resolve () {
1229 return null
1230 },
1231 }
1232
1233 const edge = new Edge({
1234 from: localFrom,
1235 type: 'prod',
1236 name: 'foo',
1237 spec: '1.x',
1238 overrides: {
1239 value: '$foo',
1240 name: 'foo',
1241 },
1242 })
1243
1244 t.equal(edge.spec, '^1.2.3', 'should fall back to local package version from devDependencies')
1245 t.end()
1246 })
1247
1248 t.test('edge with overrides should not crash when target has no overrides', t => {
1249 const root = {
1250 name: 'root',
1251 edgesOut: new Map(),
1252 edgesIn: new Set(),
1253 explain: () => 'root',
1254 package: {
1255 name: 'root',
1256 version: '1.0.0',
1257 overrides: {
1258 react: '^18.3.1',
1259 'react-dom': '^18.3.1',
1260 },
1261 },
1262 get version () {
1263 return this.package.version
1264 },
1265 isTop: true,
1266 parent: null,
1267 overrides: new OverrideSet({
1268 overrides: {
1269 react: '^18.3.1',
1270 'react-dom': '^18.3.1',
1271 },
1272 }),
1273 resolve (n) {
1274 return n === 'dep' ? dep : null
1275 },
1276 addEdgeOut (edge) {
1277 this.edgesOut.set(edge.name, edge)
1278 },
1279 addEdgeIn (edge) {
1280 this.edgesIn.add(edge)
1281 },
1282 deleteEdgeIn (edge) {
1283 this.edgesIn.delete(edge)
1284 },
1285 }
1286
1287 // Target node with dependencies but NO overrides
1288 const dep = {
1289 name: 'dep',
1290 edgesOut: new Map([
1291 // Has dependencies so edgesOut.size > 0
1292 ['some-lib', { name: 'some-lib', peer: false }],
1293 ]),
1294 edgesIn: new Set(),
1295 explain: () => 'dep',
1296 package: { name: 'dep', version: '1.0.0' },
1297 get version () {
1298 return this.package.version
1299 },
1300 parent: root,
1301 root,
1302 // NO overrides property - this causes this.#to.overrides to be undefined
1303 resolve () {
1304 return null
1305 },
1306 addEdgeOut (edge) {
1307 this.edgesOut.set(edge.name, edge)
1308 },
1309 addEdgeIn (edge) {
1310 this.edgesIn.add(edge)
1311 },
1312 deleteEdgeIn (edge) {
1313 this.edgesIn.delete(edge)
1314 },
1315 }
1316
1317 // Create an edge from root to dep
1318 // Root has overrides, dep has dependencies but no overrides
1319 const edge = new Edge({
1320 from: root,
1321 type: 'prod',
1322 spec: '^1.0.0',
1323 name: 'dep',
1324 overrides: root.overrides,
1325 })
1326
1327 t.doesNotThrow(() => {
1328 const err = edge.error
1329 t.equal(err, null, 'edge should be valid (no error)')
1330 }, 'should not crash when target node has no overrides')
1331
1332 t.ok(edge.valid, 'edge should be valid')
1333 t.end()
1334 })