@vltpkg/query 1.4.0 → 1.6.0

package/test/fixtures/selector.ts

@@ -1,103 +0,0 @@
-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, { loose: true })
-      // 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

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

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