@vltpkg/query 1.4.0 → 1.6.0

package/test/pseudo/vulnerable.ts

@@ -1,137 +0,0 @@
-import t from 'tap'
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import { asSecurityArchiveLike } from '@vltpkg/security-archive'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-import type { ParserState } from '../../src/types.ts'
-import { parse } from '../../src/parser.ts'
-import { vuln } from '../../src/pseudo/vuln.ts'
-
-t.test(':vulnerable alias works the same as :vuln', async t => {
-  const getState = (query: string, graph = getSimpleGraph()) => {
-    const ast = parse(query)
-    const current = 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,
-      securityArchive: asSecurityArchiveLike(
-        new Map([
-          [
-            joinDepIDTuple(['registry', '', 'e@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'e@1.0.0']),
-              alerts: [{ type: 'criticalCVE' }],
-            },
-          ],
-          [
-            joinDepIDTuple(['registry', '', 'a@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'a@1.0.0']),
-              alerts: [{ type: 'potentialVulnerability' }],
-            },
-          ],
-          [
-            joinDepIDTuple(['registry', '', 'c@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'c@1.0.0']),
-              alerts: [
-                {
-                  type: 'deprecated',
-                  severity: 'low' as const,
-                  category: 'maintenance',
-                  key: 'some-key-2',
-                },
-              ],
-            },
-          ],
-        ]),
-      ),
-      importers: new Set(graph.importers),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test(
-    'parameterless :vulnerable matches severity >= medium',
-    async t => {
-      const res = await vuln(getState(':vulnerable'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a', 'e'],
-        'should select packages with vuln severity >= medium',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    ':vulnerable(critical) matches same as :vuln(critical)',
-    async t => {
-      const resVulnerable = await vuln(
-        getState(':vulnerable(critical)'),
-      )
-      const resVuln = await vuln(getState(':vuln(critical)'))
-      t.strictSame(
-        [...resVulnerable.partial.nodes].map(n => n.name).sort(),
-        [...resVuln.partial.nodes].map(n => n.name).sort(),
-        'alias :vulnerable(critical) should produce identical results to :vuln(critical)',
-      )
-    },
-  )
-})
-
-t.test('missing security archive', async t => {
-  const getState = (query: string) => {
-    const ast = parse(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      partial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      securityArchive: undefined,
-      importers: new Set(),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.rejects(
-    vuln(getState(':vulnerable')),
-    { message: /Missing security archive/ },
-    'should throw an error',
-  )
-})

package/test/pseudo/workspace.ts

@@ -1,111 +0,0 @@
-import t from 'tap'
-import { pseudo } from '../../src/pseudo.ts'
-import {
-  selectorFixture,
-  copyGraphSelectionState,
-} from '../fixtures/selector.ts'
-import {
-  getSingleWorkspaceGraph,
-  getMultiWorkspaceGraph,
-} from '../fixtures/graph.ts'
-import type { TestCase } from '../fixtures/types.ts'
-import type { GraphSelectionState } from '../../src/types.ts'
-
-const testPseudo = selectorFixture(pseudo)
-
-t.test(':workspace pseudo-selector', async t => {
-  // Test with a single workspace graph
-  t.test('with single workspace', async t => {
-    // Get a graph with a single workspace
-    const singleWorkspaceGraph = getSingleWorkspaceGraph()
-
-    // Get the full selection state
-    const all = {
-      edges: new Set(singleWorkspaceGraph.edges),
-      nodes: new Set(singleWorkspaceGraph.nodes.values()),
-    }
-
-    // Create an empty selection state
-    const empty: GraphSelectionState = {
-      edges: new Set(),
-      nodes: new Set(),
-    }
-
-    // Run tests in the same pattern as the main pseudo.ts tests
-    const queryToExpected = new Set<TestCase>([
-      [':workspace', all, ['w']], // Should return only workspace nodes
-      [':workspace', empty, []], // Empty input should return empty output
-    ])
-
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-
-      // Verify all nodes are workspace nodes
-      const nodeArray = [...result.nodes]
-      if (nodeArray.length > 0) {
-        for (const node of nodeArray) {
-          t.equal(
-            node.importer && !node.mainImporter,
-            true,
-            `node ${node.name} should be a workspace node (importer=true, mainImporter=false)`,
-          )
-        }
-      }
-    }
-  })
-
-  // Test with multiple workspaces
-  t.test('with multiple workspaces', async t => {
-    // Get a graph with multiple workspaces
-    const multiWorkspaceGraph = getMultiWorkspaceGraph()
-
-    // Get the full selection state
-    const all = {
-      edges: new Set(multiWorkspaceGraph.edges),
-      nodes: new Set(multiWorkspaceGraph.nodes.values()),
-    }
-
-    // Run the test
-    const result = await testPseudo(
-      ':workspace',
-      copyGraphSelectionState(all),
-      copyGraphSelectionState(all),
-    )
-
-    // Should return all workspace nodes (a, b, c)
-    const nodeNames = [...result.nodes].map(n => n.name).sort()
-    t.strictSame(
-      nodeNames,
-      ['a', 'b', 'c'],
-      'should return all workspace nodes in multi-workspace graph',
-    )
-
-    t.matchSnapshot(
-      {
-        nodes: [...result.nodes].map(n => n.name).sort(),
-        edges: [...result.edges].map(e => e.name).sort(),
-      },
-      'should match snapshot for multi-workspace graph',
-    )
-
-    // Verify all nodes are workspace nodes
-    for (const node of result.nodes) {
-      t.equal(
-        node.importer && !node.mainImporter,
-        true,
-        `node ${node.name} should be a workspace node (importer=true, mainImporter=false)`,
-      )
-    }
-  })
-})