@vltpkg/query 1.5.0 → 1.6.0

package/test/pseudo/diff.ts

@@ -1,417 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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',
-  )
-})