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

package/test/attribute.ts

@@ -0,0 +1,266 @@
+import { joinDepIDTuple } from '@vltpkg/dep-id'
+import type { EdgeLike, NodeLike } from '@vltpkg/types'
+import type { Attribute } from 'postcss-selector-parser'
+import t from 'tap'
+import {
+  attribute,
+  filterAttributes,
+  getManifestPropertyValues,
+} from '../src/attribute.ts'
+import {
+  getMissingNodeGraph,
+  getSimpleGraph,
+} from './fixtures/graph.ts'
+import {
+  copyGraphSelectionState,
+  getGraphSelectionState,
+  selectorFixture,
+} from './fixtures/selector.ts'
+import type { TestCase } from './fixtures/types.ts'
+import type {
+  GraphSelectionState,
+  ParserState,
+} from '../src/types.ts'
+
+type ManifestLike = Record<string, any>
+
+const testAttr = selectorFixture(attribute)
+
+t.test('attribute', 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>([
+    [
+      '[version="1.0.0"]',
+      all,
+      ['my-project', 'a', 'c', 'd', 'e', 'f', '@x/y'],
+    ], // attribute matches all
+    [
+      '[name]',
+      all,
+      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
+    ], // attribute has any content
+    ['[nonexistingattribute]', all, []], // non existing attribute
+    ['[name="@x/y"]', all, ['@x/y']], // attribute matches scoped quoted
+    ['[name^=m]', all, ['my-project']], // attribute starts with value
+    ['[name^="m"]', all, ['my-project']], // attribute starts with value
+    ['[name^=@x]', all, ['@x/y']], // attribute starts with scope
+    ['[name^="@x"]', all, ['@x/y']], // attribute starts with scope
+    ['[name$=project]', all, ['my-project']], // attribute ends with value
+    ['[name$="project"]', all, ['my-project']], // attribute ends with value
+    ['[name~=project]', all, ['my-project']], // attribute contains word
+    ['[name~="project"]', all, ['my-project']], // attribute contains word
+    ['[name~=notfound]', all, []], // attribute contains not found
+    ['[name~="notfound"]', all, []], // attribute contains not found
+    ['[name*=pro]', all, ['my-project']], // attribute contains string
+    ['[name*="pro"]', all, ['my-project']], // attribute contains string
+    ['[name|=my]', all, ['my-project']], // attribute starts with hyphened string
+    ['[name|="my"]', all, ['my-project']], // attribute starts with hyphened string
+    ['[name|="a"]', all, ['a']], // also matches on exact match
+    ['[name="A"]', all, []], // case sensitive by default
+    ['[name="A" i]', all, ['a']], // case insensitive flag
+    ['[name="A" s]', all, []], // case insensitive flag
+    ['[name="a"]', empty, []], // no matches if starting from empty partial
+    ['[name="a"]', b, []], // no matches if node can't be find in partial
+    ['[name="b"]', b, ['b']], // matches single node found
+    ['[keywords=something]', all, ['c']], // matches item in array prop
+    ['[keywords=missing]', all, []], // can not match missing item in array
+  ])
+  const initial = {
+    edges: new Set(all.edges),
+    nodes: new Set(all.nodes),
+  }
+  for (const [query, partial, expected] of queryToExpected) {
+    const res = await testAttr(
+      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('missing node', async t => {
+    const missingNodeGraph = getMissingNodeGraph()
+    const all: GraphSelectionState = {
+      edges: new Set<EdgeLike>(missingNodeGraph.edges),
+      nodes: new Set<NodeLike>(missingNodeGraph.nodes.values()),
+    }
+    const queryToExpected = new Set<TestCase>([
+      ['[name]', all, ['node-missing-project']], // root node has a name
+      ['[name=a]', all, []], // can't match missing node
+    ])
+    const initial = copyGraphSelectionState(all)
+    for (const [query, partial, expected] of queryToExpected) {
+      const res = await testAttr(
+        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(
+    testAttr(':dev'),
+    /Mismatching query node/,
+    'should throw an error',
+  )
+})
+
+t.test('bad operator', async t => {
+  await t.rejects(
+    testAttr('[name==foo]'),
+    /Unsupported attribute operator: +=/,
+    'should throw an error',
+  )
+})
+
+t.test('bad operator [loose mode]', async t => {
+  await t.resolves(
+    testAttr('[name==foo]', undefined, undefined, true),
+    'should resolve with no error',
+  )
+})
+
+t.test(
+  'unquotted scoped names are not supported by the parser',
+  async t => {
+    await t.rejects(
+      testAttr('[name=@x/y]'),
+      /Unexpected "\/" found./,
+      'should throw an error',
+    )
+  },
+)
+
+t.test('getManifestPropertyValues', async t => {
+  const simpleGraph = getSimpleGraph()
+  const b = simpleGraph.nodes.get(
+    joinDepIDTuple(['registry', '', 'b@1.0.0']),
+  )!
+
+  t.strictSame(
+    getManifestPropertyValues(
+      b,
+      ['scripts', 'postinstall'],
+      'postinstall',
+    ),
+    ['postinstall'],
+    'should return the postinstall script value',
+  )
+
+  t.strictSame(
+    getManifestPropertyValues(b, ['contributors'], 'contributors'),
+    ['[object Object]'],
+    'should return a stringified object value',
+  )
+
+  t.strictSame(
+    getManifestPropertyValues(b, ['contributors', 'name'], 'name'),
+    ['Ruy Adorno'],
+    'should return the value from a array-nested object',
+  )
+
+  b.manifest = { foo: 1 } as ManifestLike
+  t.strictSame(
+    getManifestPropertyValues(b, ['foo'], 'foo'),
+    ['1'],
+    'should return values as strings',
+  )
+
+  b.manifest = { keywords: [undefined, 'foo'] } as ManifestLike
+  t.strictSame(
+    getManifestPropertyValues(b, ['keywords'], 'keywords'),
+    ['', 'foo'],
+    'should turn falsy values into empty strings',
+  )
+
+  b.manifest = 'bad manifest' as unknown as ManifestLike
+  t.strictSame(
+    getManifestPropertyValues(b, ['name'], 'name'),
+    undefined,
+    'should not return results from a bad manifest',
+  )
+
+  delete b.manifest
+  t.strictSame(
+    getManifestPropertyValues(b, ['name'], 'name'),
+    undefined,
+    'should not return results from a missing manifest',
+  )
+})
+
+t.test('filterAttributes', async t => {
+  const simpleGraph = getSimpleGraph()
+  const all: GraphSelectionState = {
+    edges: new Set<EdgeLike>(simpleGraph.edges),
+    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
+  }
+  const state = {
+    cancellable: async () => {},
+    collect: {
+      edges: new Set<EdgeLike>(),
+      nodes: new Set<NodeLike>(),
+    },
+    comment: '',
+    current: { type: 'attribute', value: 'postinstall' } as Attribute,
+    initial: copyGraphSelectionState(all),
+    partial: all,
+    loose: false,
+    importers: simpleGraph.importers,
+    hostContexts: new Map(),
+    walk: async (state: ParserState) => state,
+    retries: 0,
+    securityArchive: undefined,
+    signal: new AbortController().signal,
+    specificity: { idCounter: 0, commonCounter: 0 },
+  }
+  filterAttributes(
+    state,
+    (attr: string) => !!attr,
+    'postinstall',
+    'scripts',
+    false,
+    ['scripts', 'postinstall'],
+  )
+  t.matchSnapshot(
+    {
+      edges: [...state.partial.edges].map(i => i.name).sort(),
+      nodes: [...state.partial.nodes].map(i => i.name).sort(),
+    },
+    'should have filtered out nodes with postinstall script only',
+  )
+})

package/test/combinator.ts

@@ -0,0 +1,168 @@
+import t from 'tap'
+import { combinator } from '../src/combinator.ts'
+import { walk } from '../src/index.ts'
+import { getCycleGraph, getSimpleGraph } from './fixtures/graph.ts'
+import {
+  copyGraphSelectionState,
+  getGraphSelectionState,
+  selectorFixture,
+} from './fixtures/selector.ts'
+import type { TestCase } from './fixtures/types.ts'
+import type { EdgeLike, NodeLike } from '@vltpkg/types'
+import type { GraphSelectionState } from '../src/types.ts'
+
+const testCombinator = selectorFixture(combinator)
+
+t.test('combinator', async t => {
+  const simpleGraph = getSimpleGraph()
+  const all: GraphSelectionState = {
+    edges: new Set<EdgeLike>(simpleGraph.edges),
+    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
+  }
+  const root = {
+    edges: new Set<EdgeLike>(),
+    nodes: new Set<NodeLike>([simpleGraph.mainImporter]),
+  }
+  const b = getGraphSelectionState(simpleGraph, 'b')
+  const d = getGraphSelectionState(simpleGraph, 'd')
+  const bd: GraphSelectionState = {
+    edges: new Set<EdgeLike>([...b.edges, ...d.edges]),
+    nodes: new Set<NodeLike>([...b.nodes, ...d.nodes]),
+  }
+  const e = getGraphSelectionState(simpleGraph, 'e')
+  const f = getGraphSelectionState(simpleGraph, 'f')
+  const empty: GraphSelectionState = {
+    edges: new Set(),
+    nodes: new Set(),
+  }
+  const queryToExpected = new Set<TestCase>([
+    // child combinator
+    ['>', all, ['a', 'b', 'e', '@x/y', 'c', 'd', 'f']], // direct children of all nodes
+    ['>', root, ['a', 'b', 'e', '@x/y']], // from root
+    ['>', d, ['e', 'f']], // from transitive dep
+    ['>', bd, ['c', 'd', 'e', 'f']], // from mutiple deps
+    ['>', e, []], // from node with no deps
+    ['>', empty, []], // from empty nodes
+    // subsequent sibling combinator
+    ['~', all, ['b', 'e', '@x/y', 'a', 'd', 'c', 'f']], // siblings of all nodes
+    ['~', f, ['e']], // leaf node with a sibling
+    ['~', d, ['c']], // transitive node
+    ['~', e, ['a', 'b', '@x/y', 'f']], // node with siblings at multiple locations
+    ['~', root, []], // root has no siblings
+    ['~', empty, []], // sibling of empty nodes
+    // descendent combinator
+    [' ', root, ['a', 'b', 'e', '@x/y', 'c', 'd', 'f']], // from root
+    [' ', f, []], // leaf node
+    [' ', empty, []], // empty list of nodes
+    [' ', d, ['e', 'f']], // transitive node
+    [' ', b, ['c', 'd', 'e', 'f']], // direct dep
+  ])
+  const initial = copyGraphSelectionState(all)
+  for (const [query, partial, expected] of queryToExpected) {
+    const res = await testCombinator(
+      { value: query, type: 'combinator' },
+      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('cycle', async t => {
+    const cycleGraph = getCycleGraph()
+    const all: GraphSelectionState = {
+      edges: new Set<EdgeLike>(cycleGraph.edges),
+      nodes: new Set<NodeLike>(cycleGraph.nodes.values()),
+    }
+    const root = {
+      edges: new Set<EdgeLike>(),
+      nodes: new Set<NodeLike>([cycleGraph.mainImporter]),
+    }
+    const a = getGraphSelectionState(cycleGraph, 'a')
+    const b = getGraphSelectionState(cycleGraph, 'b')
+    const queryToExpected = new Set<TestCase>([
+      ['>', all, ['a', 'b']], // direct children of all nodes
+      ['>', a, ['b']], // direct children of a
+      ['>', b, ['a']], // direct children of b
+      [' ', root, ['a', 'b']], // descendents of :root
+      [' ', a, ['b', 'a']], // descendents of a
+      [' ', b, ['a', 'b']], // descendents of b
+      ['~', root, []], // siblings of :root
+      ['~', a, []], // siblings of a
+      ['~', b, []], // siblings of b
+    ])
+    const initial = copyGraphSelectionState(all)
+    for (const [query, partial, expected] of queryToExpected) {
+      const result = await testCombinator(
+        { value: query, type: 'combinator' },
+        initial,
+        copyGraphSelectionState(partial),
+      )
+      t.strictSame(
+        result.nodes.map(i => i.name),
+        expected,
+        `query > "${query}"`,
+      )
+      t.matchSnapshot(
+        {
+          edges: result.edges.map(i => i.name).sort(),
+          nodes: result.nodes.map(i => i.name).sort(),
+        },
+        `query > "${query}"`,
+      )
+    }
+  })
+
+  // space between tags are not descendent combinators
+  await t.test('ignore spaces between tags', async t => {
+    const test = selectorFixture(walk)
+    const result = await test(
+      '* { * }',
+      all,
+      copyGraphSelectionState(all),
+    )
+    t.strictSame(
+      result.nodes.map(i => i.name),
+      [...all.nodes].map(i => i.name),
+      'should not treat spaces between tags as descendent combinators',
+    )
+  })
+})
+
+t.test('bad selector type', async t => {
+  await t.rejects(
+    testCombinator(':dev'),
+    /Mismatching query node/,
+    'should throw an error',
+  )
+})
+
+t.test('usnupported combinator', async t => {
+  await t.rejects(
+    testCombinator({ value: '+', type: 'combinator' }),
+    /Unsupported combinator: \+/,
+    'should throw an error',
+  )
+})
+
+t.test('usnupported combinator [loose mode]', async t => {
+  await t.resolves(
+    testCombinator(
+      { value: '+', type: 'combinator' },
+      undefined,
+      undefined,
+      true,
+    ),
+    'should resolve with no error',
+  )
+})