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

package/test/pseudo/semver.ts

@@ -0,0 +1,822 @@
+import t from 'tap'
+import { asPostcssNodeWithChildren, parse } from '@vltpkg/dss-parser'
+import {
+  asSemverFunctionName,
+  isSemverFunctionName,
+  parseInternals,
+  semverParser,
+} from '../../src/pseudo/semver.ts'
+import {
+  getSemverRichGraph,
+  getSimpleGraph,
+} from '../fixtures/graph.ts'
+import type { ParserState } from '../../src/types.ts'
+
+t.test('select from semver definition', async t => {
+  const getState = (query: string, graph = getSimpleGraph()) => {
+    const ast = parse(query)
+    const current = asPostcssNodeWithChildren(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(),
+      },
+      retries: 0,
+      cancellable: async () => {},
+      walk: async i => i,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    return state
+  }
+
+  await t.test('quoted no spaces', async t => {
+    const res = await semverParser(getState(':semver(">=2")'))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['b'],
+      'should have expected result using quoted semver notation (no spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted no spaces', async t => {
+    const res = await semverParser(getState(':semver(>=2)'))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['b'],
+      'should have expected result using unquoted semver notation (no spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted with spaces', async t => {
+    const res = await semverParser(getState(':semver(">= 2")'))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['b'],
+      'should have expected result using quoted semver notation (with spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted with spaces', async t => {
+    const res = await semverParser(getState(':semver(>= 2)'))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['b'],
+      'should have expected result using unquoted semver notation (with spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted with multiple spaces', async t => {
+    const res = await semverParser(
+      getState(':semver("1 || 2 || 3 >= 4 < 5")'),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
+      'should have expected result using quoted semver notation (with multiple spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted with multiple spaces', async t => {
+    const res = await semverParser(
+      getState(':semver(1 || 2 || 3 >= 4 < 5)'),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
+      'should have expected result using unquoted semver notation (with multiple spaces)',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted lte semver', async t => {
+    const res = await semverParser(
+      getState(':semver("<=1")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['semver-rich-project@1.0.0', 'a@1.0.1', 'h@1.0.0'],
+      'should have expected result using quoted lte semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted lte semver', async t => {
+    const res = await semverParser(
+      getState(':semver(<=1)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['semver-rich-project@1.0.0', 'a@1.0.1', 'h@1.0.0'],
+      'should have expected result using unquoted lte semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted hyphen-separated semver', async t => {
+    const res = await semverParser(
+      getState(':semver("100 - 200")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['e@120.0.0'],
+      'should have expected result using quoted hyphen-separated semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted hyphen-separated semver', async t => {
+    const res = await semverParser(
+      getState(':semver(100 - 200)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['e@120.0.0'],
+      'should have expected result using unquoted hyphen-separated semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted greater than semver', async t => {
+    const res = await semverParser(
+      getState(':semver(>2.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['b@2.2.1', 'c@3.4.0', 'd@2.3.4', 'e@120.0.0', 'f@4.5.6'],
+      'should have expected result using unquoted greater than semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted greater than or equal semver', async t => {
+    const res = await semverParser(
+      getState(':semver(>=2.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['b@2.2.1', 'c@3.4.0', 'd@2.3.4', 'e@120.0.0', 'f@4.5.6'],
+      'should have expected result using unquoted greater than or equal semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted less than semver', async t => {
+    const res = await semverParser(
+      getState(':semver(<2.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['semver-rich-project@1.0.0', 'a@1.0.1', 'h@1.0.0'],
+      'should have expected result using unquoted less than semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted less than or equal semver', async t => {
+    const res = await semverParser(
+      getState(':semver(<=2.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['semver-rich-project@1.0.0', 'a@1.0.1', 'h@1.0.0'],
+      'should have expected result using unquoted less than or equal semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted pre-release semver', async t => {
+    const res = await semverParser(
+      getState(':semver("1.3.4-beta.1")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['e@1.3.4-beta.1'],
+      'should have expected result using quoted pre-release semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted pre-release semver', async t => {
+    const res = await semverParser(
+      getState(':semver(1.3.4-beta.1)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['e@1.3.4-beta.1'],
+      'should have expected result using unquoted pre-release semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted extended prerelease semver', async t => {
+    const res = await semverParser(
+      getState(':semver("1.2.3-rc.1+rev.2")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['g@1.2.3-rc.1+rev.2'],
+      'should have expected result using quoted extended prerelease semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted extended prerelease semver', async t => {
+    const res = await semverParser(
+      getState(':semver(1.2.3-rc.1+rev.2)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['g@1.2.3-rc.1+rev.2'],
+      'should have expected result using unquoted extended prerelease semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted pipe-separated semver', async t => {
+    const res = await semverParser(
+      getState(':semver("3 || 4")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['c@3.4.0', 'f@4.5.6'],
+      'should have expected result using quoted pipe-separated semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted pipe-separated semver', async t => {
+    const res = await semverParser(
+      getState(':semver(3 || 4)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['c@3.4.0', 'f@4.5.6'],
+      'should have expected result using unquoted pipe-separated semver',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('quoted custom semver function', async t => {
+    const res = await semverParser(
+      getState(':semver("2.3.4", "neq")', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      [
+        'semver-rich-project@1.0.0',
+        'a@1.0.1',
+        'b@2.2.1',
+        'c@3.4.0',
+        'e@120.0.0',
+        'f@4.5.6',
+        'g@1.2.3-rc.1+rev.2',
+        'e@1.3.4-beta.1',
+        'h@1.0.0',
+      ],
+      'should have expected result using quoted custom semver function',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted custom semver function', async t => {
+    const res = await semverParser(
+      getState(':semver(2.3.4, neq)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      [
+        'semver-rich-project@1.0.0',
+        'a@1.0.1',
+        'b@2.2.1',
+        'c@3.4.0',
+        'e@120.0.0',
+        'f@4.5.6',
+        'g@1.2.3-rc.1+rev.2',
+        'e@1.3.4-beta.1',
+        'h@1.0.0',
+      ],
+      'should have expected result using unquoted custom semver function',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('invalid pseudo selector usage', async t => {
+    await t.rejects(
+      () => semverParser(getState(':semver')),
+      /Failed to parse :semver selector/,
+      'should throw an error for invalid pseudo selector usage',
+    )
+  })
+
+  await t.test(':attr comparison value', async t => {
+    const res = await semverParser(
+      getState(
+        ':semver(10.0.0, satisfies, :attr(engines, [node]))',
+        getSemverRichGraph(),
+      ),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['b@2.2.1'],
+      'should have expected result using custom :attr comparison value',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test(
+    ':attr comparison value forcing multiple ranges comparison',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(>=10, satisfies, :attr(engines, [node]))',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        [],
+        'should not match any nodes when comparing ranges',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    ':attr matching arbitrary manifest property',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(^2, satisfies, :attr([arbitrarySemverValue]))',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['f@4.5.6'],
+        'should match arbitrary values using :attr pseudo selector',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    'string matching arbitrary manifest property',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(^2, satisfies, "arbitrarySemverValue")',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['f@4.5.6'],
+        'should match arbitrary values using string name',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    'attribute matching arbitrary manifest property',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(^2, satisfies, [arbitrarySemverValue])',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['f@4.5.6'],
+        'should match arbitrary values using attribute name',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    'diff semver function matching arbitrary manifest property',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(2.0.0, eq, "arbitrarySemverValue")',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['f@4.5.6'],
+        'should match arbitrary values using a diff semver function',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    'trying to use exact version comparison with a range value',
+    async t => {
+      await t.rejects(
+        semverParser(
+          getState(
+            ':semver(^2, eq, [arbitrarySemverValue])',
+            getSemverRichGraph(),
+          ),
+        ),
+        /invalid version/,
+        'should throw an invalid version error',
+      )
+    },
+  )
+
+  await t.test('unquoted complex semver with spaces', async t => {
+    const res = await semverParser(
+      getState(':semver(>=1.0.0 <3.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      [
+        'semver-rich-project@1.0.0',
+        'a@1.0.1',
+        'b@2.2.1',
+        'd@2.3.4',
+        'h@1.0.0',
+      ],
+      'should match nodes with versions that satisfy the range',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('unquoted semver with || (OR) operator', async t => {
+    const res = await semverParser(
+      getState(':semver(1.0.0 || >=4.0.0)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      [
+        'semver-rich-project@1.0.0',
+        'e@120.0.0',
+        'f@4.5.6',
+        'h@1.0.0',
+      ],
+      'should match nodes with versions that satisfy either condition',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test(
+    'unquoted semver with multiple comparators',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(>1.0.0 <=2.2.1 || >=4.0.0)',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['a@1.0.1', 'b@2.2.1', 'e@120.0.0', 'f@4.5.6'],
+        'should match nodes with versions that satisfy the complex conditions',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test('subset on edges - matching', async t => {
+    const res = await semverParser(
+      getState(':semver(>=1, subset)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.edges].map(e => `${e.name}@${e.spec.bareSpec}`),
+      [
+        'a@^1.0.0',
+        'b@~2.2.0',
+        'c@3 || 4 || 5',
+        'd@1.2 - 2.3.4',
+        'f@4.x.x',
+        'g@1.2.3-rc.1+rev.2',
+        'e@=1.3.4-beta.1',
+      ],
+      'should match edges whose bareSpec is a subset of the provided range',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('subset on edges - narrow range', async t => {
+    const res = await semverParser(
+      getState(':semver(^2, subset)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.edges].map(e => `${e.name}@${e.spec.bareSpec}`),
+      ['b@~2.2.0'],
+      'should match edges whose bareSpec is a subset of ^2',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('intersects on edges', async t => {
+    const res = await semverParser(
+      getState(':semver(>=3, intersects)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.edges].map(e => `${e.name}@${e.spec.bareSpec}`),
+      ['c@3 || 4 || 5', 'e@<=120', 'f@4.x.x'],
+      'should match edges whose bareSpec intersects with the provided range',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test(
+    'intersects excludes dist-tag edges (no semver)',
+    async t => {
+      const res = await semverParser(
+        getState(':semver(>=0, intersects)', getSemverRichGraph()),
+      )
+      t.notOk(
+        [...res.partial.edges].some(
+          e => e.spec.bareSpec === 'latest',
+        ),
+        'should exclude dist-tag edges that have no semver range',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test(
+    'subset with :attr comparison value (range vs manifest property)',
+    async t => {
+      const res = await semverParser(
+        getState(
+          ':semver(>=10, subset, :attr(engines, [node]))',
+          getSemverRichGraph(),
+        ),
+      )
+      t.strictSame(
+        [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+        ['b@2.2.1', 'c@3.4.0'],
+        'should match nodes whose engines.node range is a subset of >=10',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test('intersects with :attr comparison value', async t => {
+    const res = await semverParser(
+      getState(
+        ':semver(>=20, intersects, :attr(engines, [node]))',
+        getSemverRichGraph(),
+      ),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['b@2.2.1', 'c@3.4.0'],
+      'should match nodes whose engines.node range intersects >=20',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test(
+    'attribute matching arbitrary manifest property',
+    async t => {
+      await t.rejects(
+        semverParser(
+          getState(
+            ':semver(^2, satisfies, :unsupported)',
+            getSemverRichGraph(),
+          ),
+        ),
+        /Failed to parse :semver selector/,
+        'should throw an error for invalid custom attribute selector',
+      )
+    },
+  )
+
+  await t.test('unquoted custom attribute property', async t => {
+    const res = await semverParser(
+      getState(
+        ':semver(^2, satisfies, arbitrarySemverValue)',
+        getSemverRichGraph(),
+      ),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['b@2.2.1', 'd@2.3.4'],
+      'should match arbitrary values using unquoted property name',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test(
+    'unquoted semver function with unquoted attribute property',
+    async t => {
+      await t.rejects(
+        semverParser(
+          getState(
+            ':semver(^2, eq, arbitrarySemverValue)',
+            getSemverRichGraph(),
+          ),
+        ),
+        /invalid version/,
+        'should throw an invalid version error',
+      )
+    },
+  )
+
+  await t.test('unquoted semver with +-. characters', async t => {
+    const res = await semverParser(
+      getState(':semver(1.2.3-rc.1+rev.2)', getSemverRichGraph()),
+    )
+    t.strictSame(
+      [...res.partial.nodes].map(n => `${n.name}@${n.version}`),
+      ['g@1.2.3-rc.1+rev.2'],
+      'should match from version with reserved characters',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+})
+
+t.test('isSemverFunctionName', async t => {
+  t.ok(
+    isSemverFunctionName('satisfies'),
+    'should return true for valid semver function name',
+  )
+  t.ok(
+    isSemverFunctionName('subset'),
+    'should return true for subset function name',
+  )
+  t.ok(
+    isSemverFunctionName('intersects'),
+    'should return true for intersects function name',
+  )
+  t.notOk(
+    isSemverFunctionName('unsupported'),
+    'should return false for valid semver function name',
+  )
+})
+
+t.test('asSemverFunctionName', async t => {
+  t.throws(
+    () => asSemverFunctionName('unsupported'),
+    /Invalid semver function name/,
+    'should throw an error for invalid semver function name',
+  )
+  t.ok(
+    asSemverFunctionName('eq'),
+    'should return valid semver function name',
+  )
+})
+
+t.test('parse an element other than semver', async t => {
+  const ast = parse(':root')
+  const notSemver = asPostcssNodeWithChildren(ast.first.first).nodes
+  t.throws(
+    () => parseInternals(notSemver, false),
+    /Expected a query node/,
+    'should bubble up original thrown error',
+  )
+})
+
+t.test('parse an invalid semver function name', async t => {
+  const ast = parse(':semver(^1.0.0, ":unsupported")')
+  const notSemver = asPostcssNodeWithChildren(ast.first.first).nodes
+  t.throws(
+    () => parseInternals(notSemver, false),
+    /Invalid semver function name/,
+    'should throw an error for invalid semver function name',
+  )
+})