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

package/test/fixtures/selector.ts

@@ -0,0 +1,103 @@
+import { joinDepIDTuple } from '@vltpkg/dep-id'
+import { parse } from '@vltpkg/dss-parser'
+import { walk } from '../../src/index.ts'
+import type { EdgeLike, GraphLike, NodeLike } from '@vltpkg/types'
+import type { DepID } from '@vltpkg/dep-id'
+import type { PostcssNode } from '@vltpkg/dss-parser'
+import type {
+  GraphSelectionState,
+  ParserState,
+  ParserFn,
+} from '../../src/types.ts'
+
+export type FixtureResult = {
+  edges: EdgeLike[]
+  nodes: NodeLike[]
+}
+
+export const copyGraphSelectionState = (
+  gss: GraphSelectionState,
+): GraphSelectionState => ({
+  edges: new Set(gss.edges),
+  nodes: new Set(gss.nodes),
+})
+
+export const getGraphSelectionState = (
+  graph: GraphLike,
+  name: string,
+): GraphSelectionState => {
+  const nodes = new Set<NodeLike>([
+    graph.nodes.get(
+      joinDepIDTuple(['registry', '', `${name}@1.0.0`]),
+    )!,
+  ])
+  const edges = new Set<EdgeLike>()
+  for (const edge of graph.edges) {
+    if (edge.name === name) edges.add(edge)
+  }
+  return {
+    edges,
+    nodes,
+  }
+}
+
+/**
+ * Creates a {@link ParserState} state object and runs the provided `testFn`
+ * using that, returns an array of the resulting {@link NodeLike} nodes.
+ */
+export const selectorFixture =
+  (testFn: ParserFn) =>
+  async (
+    query: { value: string; type: string } | string,
+    initial?: GraphSelectionState,
+    partial?: GraphSelectionState,
+    loose?: boolean,
+    scopeIDs?: DepID[],
+  ): Promise<FixtureResult> => {
+    initial ??= {
+      edges: new Set(),
+      nodes: new Set(),
+    }
+    partial ??= {
+      edges: new Set(),
+      nodes: new Set(),
+    }
+    scopeIDs ??= [joinDepIDTuple(['file', '.'])]
+    let current: PostcssNode
+    if (typeof query === 'string') {
+      const ast = parse(query)
+      // if the testing function handles a fully parsed
+      // css ast then just use that instead
+      current =
+        testFn === walk ? ast : (
+          (ast.nodes[0]?.nodes[0] as PostcssNode)
+        )
+    } else {
+      current = query as PostcssNode
+    }
+    const state: ParserState = {
+      cancellable: async () => {},
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      comment: '',
+      current,
+      loose,
+      initial,
+      partial,
+      importers: new Set<NodeLike>(),
+      hostContexts: undefined,
+      walk,
+      retries: 0,
+      scopeIDs,
+      securityArchive: undefined,
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    const res = await testFn(state)
+    return {
+      edges: [...res.partial.edges],
+      nodes: [...res.partial.nodes],
+    }
+  }

package/test/fixtures/types.ts

@@ -0,0 +1,7 @@
+import type { GraphSelectionState } from '../../src/types.ts'
+
+export type TestCase = [
+  string, // query
+  GraphSelectionState, // partial state nodes to start from
+  string[], // list of expected result names
+]

package/test/id.ts

@@ -0,0 +1,102 @@
+import t from 'tap'
+import { id } from '../src/id.ts'
+import { getAliasedGraph, getSimpleGraph } from './fixtures/graph.ts'
+import {
+  copyGraphSelectionState,
+  getGraphSelectionState,
+  selectorFixture,
+} from './fixtures/selector.ts'
+import type { TestCase } from './fixtures/types.ts'
+import type { GraphSelectionState } from '../src/types.ts'
+import type { EdgeLike, NodeLike } from '@vltpkg/types'
+
+const testId = selectorFixture(id)
+
+t.test('id', async t => {
+  const simpleGraph = getSimpleGraph()
+  const all: GraphSelectionState = {
+    edges: new Set<EdgeLike>(simpleGraph.edges),
+    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
+  }
+  const b = getGraphSelectionState(simpleGraph, 'b')
+  const empty: GraphSelectionState = {
+    edges: new Set(),
+    nodes: new Set(),
+  }
+  const queryToExpected = new Set<TestCase>([
+    ['#my-project', all, ['my-project']], // select root node
+    ['#a', all, ['a']], // direct dep
+    ['#f', all, ['f']], // transitive dep
+    ['#a', b, []], // missing from partial
+    ['#b', b, ['b']], // exact match from partial
+    ['#a', empty, []], // no partial
+  ])
+  const initial = copyGraphSelectionState(all)
+  for (const [query, partial, expected] of queryToExpected) {
+    const res = await testId(
+      query,
+      initial,
+      copyGraphSelectionState(partial),
+    )
+    t.strictSame(
+      res.nodes.map(i => i.name),
+      expected,
+      `query > "${query}"`,
+    )
+    t.matchSnapshot(
+      {
+        edges: res.edges.map(i => i.name).sort(),
+        nodes: res.nodes.map(i => i.name).sort(),
+      },
+      `query > "${query}"`,
+    )
+  }
+
+  await t.test('aliased graph', async t => {
+    const aliasedGraph = getAliasedGraph()
+    const all: GraphSelectionState = {
+      edges: new Set<EdgeLike>(aliasedGraph.edges),
+      nodes: new Set<NodeLike>(aliasedGraph.nodes.values()),
+    }
+    const empty: GraphSelectionState = {
+      edges: new Set(),
+      nodes: new Set(),
+    }
+    const queryToExpected = new Set<TestCase>([
+      ['#aliased-project', all, ['aliased-project']], // select root node
+      ['#a', all, ['a']], // regular direct dep
+      ['#b', all, ['foo']], // select aliased dep by its dep name alias
+      ['#foo', all, []], // do not select aliased dep by its pkg name
+      ['#bar', all, ['d']], // select transitive aliased dep by its alias
+      ['#a', empty, []], // no partial
+    ])
+    const initial = copyGraphSelectionState(all)
+    for (const [query, partial, expected] of queryToExpected) {
+      const res = await testId(
+        query,
+        initial,
+        copyGraphSelectionState(partial),
+      )
+      t.strictSame(
+        res.nodes.map(i => i.name),
+        expected,
+        `query > "${query}"`,
+      )
+      t.matchSnapshot(
+        {
+          edges: res.edges.map(i => i.name).sort(),
+          nodes: res.nodes.map(i => i.name).sort(),
+        },
+        `query > "${query}"`,
+      )
+    }
+  })
+})
+
+t.test('bad selector type', async t => {
+  await t.rejects(
+    testId(':foo'),
+    /Mismatching query node/,
+    'should throw an error',
+  )
+})