@vltpkg/query 1.0.0-rc.32 → 1.0.0-rc.34

package/test/pseudo/root.ts

@@ -0,0 +1,66 @@
+import t from 'tap'
+import postcssSelectorParser from 'postcss-selector-parser'
+import type { ParserState } from '../../src/types.ts'
+import { root } from '../../src/pseudo/root.ts'
+import {
+  getSimpleGraph,
+  getSingleWorkspaceGraph,
+} from '../fixtures/graph.ts'
+
+t.test('selects the root node of the graph', async t => {
+  const getState = (query: string, graph = getSimpleGraph()) => {
+    const ast = postcssSelectorParser().astSync(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,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    return state
+  }
+
+  await t.test('selects root node in simple graph', async t => {
+    const res = await root(getState(':root'))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['my-project'],
+      'should select only the root node',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('selects root node in workspace graph', async t => {
+    const wsGraph = getSingleWorkspaceGraph()
+    const res = await root(getState(':root', wsGraph))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['ws'],
+      'should select only the workspace root node',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+})

package/test/pseudo/scanned.ts

@@ -0,0 +1,78 @@
+import t from 'tap'
+import { joinDepIDTuple } from '@vltpkg/dep-id'
+import { asSecurityArchiveLike } from '@vltpkg/security-archive'
+import type { PackageReportData } from '@vltpkg/security-archive'
+import { scanned } from '../../src/pseudo/scanned.ts'
+import { getSimpleGraph } from '../fixtures/graph.ts'
+import type { ParserState } from '../../src/types.ts'
+import { parse } from '../../src/parser.ts'
+
+t.test('scanned selector', async t => {
+  const getState = () => {
+    const graph = getSimpleGraph()
+    const ast = parse(':scanned')
+    const current = ast.first.first
+    const testId = joinDepIDTuple(['registry', '', 'e@1.0.0'])
+    const securityArchive = asSecurityArchiveLike(
+      new Map<string, PackageReportData>([
+        [
+          testId,
+          {
+            id: 'e@1.0.0',
+            author: [],
+            size: 0,
+            type: 'npm',
+            name: 'e',
+            version: '1.0.0',
+            license: 'MIT',
+            score: {
+              overall: 0,
+              license: 0,
+              maintenance: 0,
+              quality: 0,
+              supplyChain: 0,
+              vulnerability: 0,
+            },
+            alerts: [],
+          },
+        ],
+      ]),
+    )
+    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,
+      importers: new Set(graph.importers),
+      retries: 0,
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    return state
+  }
+
+  const state = getState()
+  const result = await scanned(state)
+  t.matchSnapshot(
+    {
+      nodes: [...result.partial.nodes].map(n => n.id),
+      edges: [...result.partial.edges].map(
+        e => `${e.from.id}->${e.to?.id}`,
+      ),
+    },
+    'should return only nodes with security archive data available',
+  )
+})