mirror of https://gitee.com/openkylin/npm.git
120 lines
2.8 KiB
JavaScript
120 lines
2.8 KiB
JavaScript
const t = require('tap')
|
|
const gatherDepSet = require('../lib/gather-dep-set.js')
|
|
|
|
const Node = require('../lib/node.js')
|
|
|
|
/*
|
|
tree (a, b, c)
|
|
+-- a (x, y)
|
|
+-- x (b)
|
|
+-- y (i)
|
|
+-- b (i, j)
|
|
+-- i (j, k)
|
|
+-- j (k)
|
|
+-- k ()
|
|
+-- c (r, s)
|
|
+-- r (s, t)
|
|
+-- s (t)
|
|
+-- t (missing) <-- unmet dependency
|
|
|
|
logical tree:
|
|
tree
|
|
+-- a
|
|
| +-- x
|
|
| | +-- b (deduped)
|
|
| +-- y
|
|
| +-- i (deduped)
|
|
+-- b
|
|
| +-- i
|
|
| | +-- j (deduped)
|
|
| | +-- k
|
|
| +-- j
|
|
| +-- k (deduped)
|
|
+-- c
|
|
+-- r
|
|
| +-- s (deduped)
|
|
| +-- t (deduped)
|
|
+-- s
|
|
+-- t
|
|
+-- missing (error, missing)
|
|
|
|
Gather dep set, ignoring edges coming from or going to root.
|
|
|
|
Gathering from a will include b. Gathering from c will not. Gathering from b
|
|
alone will be an empty set.
|
|
*/
|
|
|
|
const tree = new Node({
|
|
path: '/path/to/tree',
|
|
pkg: {
|
|
dependencies: {
|
|
a: '',
|
|
b: '',
|
|
c: '',
|
|
},
|
|
},
|
|
children: [
|
|
// [name, [deps]]
|
|
['a', ['x', 'y']],
|
|
['x', ['b']],
|
|
['y', ['i']],
|
|
['b', ['i', 'j']],
|
|
['i', ['j', 'k']],
|
|
['j', ['k']],
|
|
['k', []],
|
|
['c', ['r', 's']],
|
|
['r', ['s', 't']],
|
|
['s', ['t']],
|
|
['t', ['missing']],
|
|
].map(([name, deps]) => ({
|
|
pkg: {
|
|
name,
|
|
version: '1.0.0',
|
|
dependencies: deps.reduce((d, n) => {
|
|
d[n] = ''
|
|
return d
|
|
}, {}),
|
|
},
|
|
})),
|
|
})
|
|
|
|
const normalizePath = path => path.replace(/[A-Z]:/, '').replace(/\\/g, '/')
|
|
|
|
const printSet = set => [...set]
|
|
.sort((a, b) => a.name.localeCompare(b.name, 'en'))
|
|
.map(n => n.location)
|
|
|
|
const cwd = normalizePath(process.cwd())
|
|
t.cleanSnapshot = s => s.split(cwd).join('{CWD}')
|
|
|
|
t.formatSnapshot = obj => obj instanceof Set ? printSet(obj) : obj
|
|
|
|
const nodeA = tree.children.get('a')
|
|
const nodeB = tree.children.get('b')
|
|
const nodeC = tree.children.get('c')
|
|
const nodeX = tree.children.get('x')
|
|
|
|
const f = edge => edge.from !== tree && edge.to !== tree
|
|
|
|
const setA = gatherDepSet(new Set([nodeA]), f)
|
|
t.matchSnapshot(setA, 'set with a')
|
|
t.equal(setA.has(nodeB), true, 'set(a) includes node b')
|
|
t.equal(setA.has(nodeC), false, 'set(a) does not include node c')
|
|
t.equal(setA.has(nodeX), true, 'set(a) includes node x')
|
|
|
|
const setAX = gatherDepSet(new Set([nodeA, nodeX]), f)
|
|
t.matchSnapshot(setAX, 'set with a and x')
|
|
t.equal(setAX.has(nodeB), true, 'set(ax) includes node b')
|
|
t.equal(setAX.has(nodeC), false, 'set(ax) does not include node c')
|
|
|
|
const setB = gatherDepSet(new Set([nodeB]), f)
|
|
t.matchSnapshot(setB, 'set with b')
|
|
t.equal(setB.size, 0, 'gathering dep set from b is an empty set')
|
|
|
|
const setC = gatherDepSet(new Set([nodeC]), f)
|
|
t.matchSnapshot(setC, 'set with c only')
|
|
t.equal(setC.has(nodeC), true, 'set(c) includes node c')
|
|
t.equal(setC.has(nodeA), false, 'set(c) does not includes node a')
|
|
t.equal(setC.has(nodeB), false, 'set(c) does not includes node b')
|
|
t.equal(setC.has(nodeX), false, 'set(c) does not includes node b')
|