@vltpkg/query 1.0.0-rc.9 → 1.0.1

package/test/pseudo/diff.ts

@@ -0,0 +1,417 @@
+import t from 'tap'
+import { diff, packageHasChanges } from '../../src/pseudo/diff.ts'
+import { pseudo } from '../../src/pseudo.ts'
+import { walk } from '../../src/index.ts'
+import {
+  getPathBasedGraph,
+  getSimpleGraph,
+} from '../fixtures/graph.ts'
+import type { ParserState } from '../../src/types.ts'
+import type { GraphLike, NodeLike } from '@vltpkg/types'
+import { parse } from '@vltpkg/dss-parser'
+
+const getState = (
+  query: string,
+  graph: GraphLike = getPathBasedGraph(),
+  changedFiles?: Set<string>,
+) => {
+  const ast = parse(query)
+  const current = ast.first.first
+  const state: ParserState = {
+    comment: '',
+    current,
+    diffFiles: changedFiles ? () => changedFiles : undefined,
+    initial: {
+      edges: new Set(graph.edges.values()),
+      nodes: new Set(graph.nodes.values()),
+    },
+    partial: {
+      edges: new Set(graph.edges.values()),
+      nodes: new Set(graph.nodes.values()),
+    },
+    collect: {
+      edges: new Set(),
+      nodes: new Set(),
+    },
+    cancellable: async () => {},
+    walk: async i => i,
+    retries: 0,
+    securityArchive: undefined,
+    importers: new Set(graph.importers),
+    signal: new AbortController().signal,
+    specificity: { idCounter: 0, commonCounter: 0 },
+  }
+  return state
+}
+
+t.test('packageHasChanges', async t => {
+  t.test(
+    'returns true when files match package location',
+    async t => {
+      const changedFiles = new Set([
+        'packages/a/src/index.ts',
+        'packages/b/test/foo.ts',
+        'README.md',
+      ])
+      t.equal(packageHasChanges(changedFiles, 'packages/a'), true)
+      t.equal(packageHasChanges(changedFiles, 'packages/b'), true)
+    },
+  )
+
+  t.test(
+    'returns false when no files match package location',
+    async t => {
+      const changedFiles = new Set([
+        'packages/a/src/index.ts',
+        'README.md',
+      ])
+      t.equal(packageHasChanges(changedFiles, 'packages/c'), false)
+    },
+  )
+
+  t.test('handles root package location', async t => {
+    const changedFiles = new Set(['README.md'])
+    t.equal(packageHasChanges(changedFiles, '.'), true)
+    t.equal(packageHasChanges(changedFiles, ''), true)
+    const empty = new Set<string>()
+    t.equal(packageHasChanges(empty, '.'), false)
+    t.equal(packageHasChanges(empty, ''), false)
+  })
+
+  t.test('handles leading ./ in package location', async t => {
+    const changedFiles = new Set(['packages/a/src/index.ts'])
+    t.equal(packageHasChanges(changedFiles, './packages/a'), true)
+  })
+
+  t.test('does not match partial directory names', async t => {
+    const changedFiles = new Set(['packages/abc/src/index.ts'])
+    t.equal(
+      packageHasChanges(changedFiles, 'packages/ab'),
+      false,
+      'should not match partial dir name',
+    )
+  })
+
+  t.test('matches exact file as package location', async t => {
+    const changedFiles = new Set(['packages/a'])
+    t.equal(packageHasChanges(changedFiles, 'packages/a'), true)
+  })
+})
+
+t.test(':diff pseudo-selector', async t => {
+  t.test('filters nodes based on changed files', async t => {
+    const graph = getPathBasedGraph()
+    const changedFiles = new Set([
+      'packages/a/src/index.ts',
+      'packages/b/test/foo.ts',
+    ])
+    const state = getState(':diff(main)', graph, changedFiles)
+
+    const res = await diff(state)
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.ok(names.includes('a'), 'should include a')
+    t.ok(names.includes('b'), 'should include b')
+  })
+
+  t.test(
+    'returns no non-root nodes when no files changed',
+    async t => {
+      const graph = getPathBasedGraph()
+      const changedFiles = new Set<string>()
+      const state = getState(':diff(HEAD~1)', graph, changedFiles)
+
+      const res = await diff(state)
+      const names = [...res.partial.nodes].map(n => n.name)
+      t.strictSame(
+        names.filter(n => n !== 'path-based-project'),
+        [],
+        'should have no non-root nodes when no changes',
+      )
+    },
+  )
+
+  t.test('defaults to HEAD when no argument provided', async t => {
+    const graph = getPathBasedGraph()
+    let capturedCommitish = ''
+    const state = getState(':diff()', graph, new Set<string>())
+    state.diffFiles = (commitish: string) => {
+      capturedCommitish = commitish
+      return new Set<string>()
+    }
+    await diff(state)
+    t.equal(
+      capturedCommitish,
+      'HEAD',
+      'should default to HEAD for empty :diff()',
+    )
+  })
+
+  t.test('throws on invalid argument', async t => {
+    const graph = getPathBasedGraph()
+    const state = getState(':diff([attr])', graph, new Set<string>())
+    await t.rejects(
+      async () => diff(state),
+      {
+        message: 'Failed to parse :diff selector',
+      },
+      'should throw for unparseable :diff() argument',
+    )
+  })
+
+  t.test('throws when diffFiles provider is missing', async t => {
+    const graph = getSimpleGraph()
+    // state without diffFiles
+    const state = getState(':diff(main)', graph)
+    await t.rejects(
+      async () => diff(state),
+      {
+        message: 'The :diff() selector requires a diffFiles provider',
+      },
+      'should throw when diffFiles not provided',
+    )
+  })
+
+  t.test('throws when diffFiles provider throws', async t => {
+    const graph = getSimpleGraph()
+    const ast = parse(':diff(main)')
+    const current = ast.first.first
+    const state: ParserState = {
+      comment: '',
+      current,
+      diffFiles: () => {
+        throw new Error('git diff failed')
+      },
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      cancellable: async () => {},
+      walk: async i => i,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    t.throws(
+      () => state.diffFiles?.('main'),
+      { message: 'git diff failed' },
+      'diffFiles provider should propagate errors',
+    )
+  })
+
+  t.test(
+    'works with path-based graph and matching changes',
+    async t => {
+      const graph = getPathBasedGraph()
+      const changedFiles = new Set([
+        'packages/a/src/index.ts',
+        'c/lib/util.ts',
+      ])
+      const state = getState(':diff(main)', graph, changedFiles)
+
+      const res = await diff(state)
+      const names = [...res.partial.nodes].map(n => n.name).sort()
+      t.ok(names.includes('a'), 'should include a (packages/a)')
+      t.ok(names.includes('c'), 'should include c')
+      t.notOk(
+        names.includes('b'),
+        'should not include b (packages/b has no changes)',
+      )
+    },
+  )
+
+  t.test('registered as pseudo selector in map', async t => {
+    // Verify :diff is in the pseudo selector map by
+    // testing through the pseudo function directly with
+    // a properly configured state
+    const graph = getPathBasedGraph()
+    const changedFiles = new Set(['packages/a/src/index.ts'])
+    const ast = parse(':diff(main)')
+    const current = ast.first.first
+    const state: ParserState = {
+      comment: '',
+      current,
+      diffFiles: () => changedFiles,
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      cancellable: async () => {},
+      walk: async i => i,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    const res = await pseudo(state)
+    t.ok(
+      [...res.partial.nodes].some(n => n.name === 'a'),
+      'should return results when called through pseudo',
+    )
+    t.equal(
+      res.specificity.commonCounter,
+      1,
+      'should increment specificity commonCounter',
+    )
+  })
+
+  t.test('passes commitish to diffFiles provider', async t => {
+    const graph = getPathBasedGraph()
+    let capturedCommitish = ''
+    const ast = parse(':diff(HEAD~3)')
+    const current = ast.first.first
+    const state: ParserState = {
+      comment: '',
+      current,
+      diffFiles: (commitish: string) => {
+        capturedCommitish = commitish
+        return new Set<string>()
+      },
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      cancellable: async () => {},
+      walk: async i => i,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    await diff(state)
+    t.equal(
+      capturedCommitish,
+      'HEAD~3',
+      'should pass commitish to provider',
+    )
+  })
+})
+
+t.test(':diff inside nested selectors', async t => {
+  const makeNestedState = (
+    query: string,
+    graph: GraphLike,
+    changedFiles: Set<string>,
+  ): ParserState => {
+    const ast = parse(query)
+    return {
+      comment: '',
+      current: ast,
+      diffFiles: () => changedFiles,
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set<NodeLike>(),
+      },
+      cancellable: async () => {},
+      walk,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+  }
+
+  t.test(
+    ':has(> :diff) propagates diffFiles to nested state',
+    async t => {
+      const graph = getPathBasedGraph()
+      const changedFiles = new Set(['packages/a/src/index.ts'])
+      const state = makeNestedState(
+        ':has(> :diff(main))',
+        graph,
+        changedFiles,
+      )
+      const res = await walk(state)
+      const names = [...res.collect.nodes].map(n => n.name).sort()
+      t.ok(
+        names.includes('path-based-project'),
+        'root should match because it has child "a" that changed',
+      )
+    },
+  )
+
+  t.test(
+    ':not(:diff) propagates diffFiles to nested state',
+    async t => {
+      const graph = getPathBasedGraph()
+      const changedFiles = new Set(['packages/a/src/index.ts'])
+      const state = makeNestedState(
+        ':not(:diff(main))',
+        graph,
+        changedFiles,
+      )
+      const res = await walk(state)
+      const names = [...res.collect.nodes].map(n => n.name).sort()
+      t.notOk(
+        names.includes('a'),
+        'a should be excluded by :not(:diff) since it changed',
+      )
+      t.ok(
+        names.includes('x'),
+        'x should remain since its files did not change',
+      )
+    },
+  )
+
+  t.test(
+    ':is(:diff) propagates diffFiles to nested state',
+    async t => {
+      const graph = getPathBasedGraph()
+      const changedFiles = new Set([
+        'packages/a/src/index.ts',
+        'packages/b/test/foo.ts',
+      ])
+      const state = makeNestedState(
+        ':is(:diff(main))',
+        graph,
+        changedFiles,
+      )
+      const res = await walk(state)
+      const names = [...res.collect.nodes].map(n => n.name).sort()
+      t.ok(
+        names.includes('a'),
+        'a should match :is(:diff) since it changed',
+      )
+      t.ok(
+        names.includes('b'),
+        'b should match :is(:diff) since it changed',
+      )
+    },
+  )
+})

package/test/pseudo/dist.ts

@@ -0,0 +1,215 @@
+import t from 'tap'
+import { joinDepIDTuple } from '@vltpkg/dep-id'
+import { parse, asPostcssNodeWithChildren } from '@vltpkg/dss-parser'
+import {
+  dist,
+  queueNode,
+  retrieveDistTags,
+} from '../../src/pseudo/dist.ts'
+import { getSimpleGraph } from '../fixtures/graph.ts'
+import type { NodeLike } from '@vltpkg/types'
+import type { ParserState } from '../../src/types.ts'
+
+global.fetch = (async (url: string) => {
+  if (url === 'https://registry.npmjs.org/c') {
+    return {
+      status: 404,
+      ok: false,
+    }
+  } else if (url === 'https://registry.npmjs.org/d') {
+    return {
+      ok: false,
+    }
+  } else if (url === 'https://registry.npmjs.org/e') {
+    throw new Error('ERR')
+  }
+  return {
+    ok: true,
+    json: async () => {
+      switch (url) {
+        case 'https://registry.npmjs.org/a': {
+          return {
+            'dist-tags': {
+              latest: '1.0.0',
+              nightly: '2.0.0',
+            },
+          }
+        }
+        case 'https://registry.npmjs.org/b': {
+          return {
+            'dist-tags': {
+              latest: '2.0.0',
+              beta: '1.0.0',
+            },
+          }
+        }
+        case 'https://registry.npmjs.org/f': {
+          return {
+            'dist-tags': {
+              latest: '1.0.0',
+            },
+          }
+        }
+      }
+    },
+  }
+}) as unknown as typeof global.fetch
+
+const getState = (query: string, graph = getSimpleGraph()) => {
+  const ast = parse(query)
+  const current = asPostcssNodeWithChildren(ast.first.first)
+  const state: ParserState = {
+    comment: '',
+    current,
+    initial: {
+      edges: new Set(graph.edges.values()),
+      nodes: new Set(graph.nodes.values()),
+    },
+    partial: {
+      edges: new Set(graph.edges.values()),
+      nodes: new Set(graph.nodes.values()),
+    },
+    collect: {
+      edges: new Set(),
+      nodes: new Set(),
+    },
+    cancellable: async () => {},
+    walk: async i => i,
+    retries: 0,
+    securityArchive: undefined,
+    importers: new Set(graph.importers),
+    signal: new AbortController().signal,
+    specificity: { idCounter: 0, commonCounter: 0 },
+  }
+  return state
+}
+
+t.test(':dist pseudo-selector', async t => {
+  t.capture(console, 'warn')
+
+  await t.test('matches nodes at the latest dist-tag', async t => {
+    const res = await dist(getState(':dist(latest)'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.strictSame(
+      names,
+      ['a', 'f'],
+      'should match only nodes whose version equals the latest dist-tag',
+    )
+    t.matchSnapshot({
+      nodes: names,
+      edges: [...res.partial.edges].map(e => e.name).sort(),
+    })
+  })
+
+  await t.test('matches nodes at the beta dist-tag', async t => {
+    const res = await dist(getState(':dist(beta)'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.strictSame(
+      names,
+      ['b'],
+      'should match only nodes whose version equals the beta dist-tag',
+    )
+    t.matchSnapshot({
+      nodes: names,
+      edges: [...res.partial.edges].map(e => e.name).sort(),
+    })
+  })
+
+  await t.test('matches nodes at the nightly dist-tag', async t => {
+    const res = await dist(getState(':dist(nightly)'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.strictSame(
+      names,
+      [],
+      'should match nothing since no installed version is 2.0.0',
+    )
+  })
+
+  await t.test('supports quoted tag name', async t => {
+    const res = await dist(getState(':dist("latest")'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.strictSame(
+      names,
+      ['a', 'f'],
+      'should work with quoted tag names',
+    )
+  })
+
+  await t.test('unknown dist-tag returns no matches', async t => {
+    const res = await dist(getState(':dist(nonexistent)'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.strictSame(
+      names,
+      [],
+      'should return no matches for an unknown dist-tag',
+    )
+  })
+
+  await t.test('handles empty partial state', async t => {
+    const state = getState(':dist(latest)')
+    state.partial.nodes.clear()
+    state.partial.edges.clear()
+
+    const res = await dist(state)
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      [],
+      'should return empty results from an empty partial state',
+    )
+  })
+
+  await t.test('gracefully handles fetch errors', async t => {
+    const res = await dist(getState(':dist(latest)'))
+    const names = [...res.partial.nodes].map(n => n.name).sort()
+    t.ok(
+      !names.includes('d') && !names.includes('e'),
+      'nodes with fetch errors should not be in results',
+    )
+  })
+})
+
+t.test('retrieveDistTags', async t => {
+  const missingName = {
+    id: joinDepIDTuple(['registry', '', 'a@1.0.0']),
+  } as NodeLike
+  t.strictSame(
+    await retrieveDistTags(missingName),
+    {},
+    'should return empty object if missing essential info',
+  )
+
+  await t.test('no response from registry', async t => {
+    const node = {
+      name: 'd',
+      id: joinDepIDTuple(['registry', '', 'd@1.0.0']),
+    } as NodeLike
+    await t.rejects(
+      retrieveDistTags(node),
+      /Failed to fetch packument/,
+      'should throw an internal error so that it may be retried',
+    )
+  })
+
+  await t.test('fetch error', async t => {
+    const node = {
+      name: 'e',
+      id: joinDepIDTuple(['registry', '', 'e@1.0.0']),
+    } as NodeLike
+    await t.rejects(
+      retrieveDistTags(node),
+      /ERR/,
+      'should throw the original error that will be retried',
+    )
+  })
+})
+
+t.test('queueNode', async t => {
+  const missingName = {
+    id: joinDepIDTuple(['registry', '', 'a@1.0.0']),
+  } as NodeLike
+  t.strictSame(
+    await queueNode(getState(':dist(latest)'), missingName, 'latest'),
+    missingName,
+    'should return node for removal if missing essential info',
+  )
+})