@vltpkg/query 1.4.0 → 1.6.0

package/test/pseudo/scripts.ts

@@ -1,324 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import { normalizeManifest } from '@vltpkg/types'
-import type { ParserState } from '../../src/types.ts'
-import { scripts } from '../../src/pseudo/scripts.ts'
-import { newGraph, newNode } from '../fixtures/graph.ts'
-import type { NodeLike } from '@vltpkg/types'
-
-t.test('selects packages that need to be built', async t => {
-  const getState = (query: string, nodes: NodeLike[] = []) => {
-    const ast = postcssSelectorParser().astSync(query)
-    const current = ast.first.first
-
-    // Create a minimal graph with our test nodes
-    const graph = newGraph('test-project')
-    nodes.forEach(node => {
-      graph.nodes.set(node.id, node)
-    })
-
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(nodes),
-      },
-      partial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(nodes),
-      },
-      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
-  }
-
-  const createTestNode = (name: string, manifest: any): NodeLike => {
-    const graph = newGraph('test')
-    const addNode = newNode(graph)
-    const node = addNode(name)
-    node.manifest = normalizeManifest({
-      name,
-      version: '1.0.0',
-      ...manifest,
-    })
-    return node
-  }
-
-  await t.test(
-    'selects nodes with install lifecycle scripts',
-    async t => {
-      const nodeWithInstall = createTestNode('install-pkg', {
-        scripts: { install: 'echo installing' },
-      })
-      const nodeWithPreinstall = createTestNode('preinstall-pkg', {
-        scripts: { preinstall: 'echo pre installing' },
-      })
-      const nodeWithPostinstall = createTestNode('postinstall-pkg', {
-        scripts: { postinstall: 'echo post installing' },
-      })
-      const nodeWithoutScripts = createTestNode('no-scripts-pkg', {})
-      // abbreviated registry manifest: no scripts, only the flag
-      const nodeWithFlag = createTestNode('abbreviated-pkg', {
-        hasInstallScript: true,
-      })
-
-      const res = await scripts(
-        getState(':scripts', [
-          nodeWithInstall,
-          nodeWithPreinstall,
-          nodeWithPostinstall,
-          nodeWithoutScripts,
-          nodeWithFlag,
-        ]),
-      )
-
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        [
-          'abbreviated-pkg',
-          'install-pkg',
-          'postinstall-pkg',
-          'preinstall-pkg',
-        ],
-        'should select packages with install lifecycle scripts',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects git dependencies with prepare scripts',
-    async t => {
-      const gitNodeWithPrepare = createTestNode('git-pkg', {
-        scripts: { prepare: 'npm run build' },
-      })
-      gitNodeWithPrepare.id = joinDepIDTuple([
-        'git',
-        'github.com/user/repo.git',
-        'git-pkg@1.0.0',
-      ])
-
-      const gitNodeWithPreprepare = createTestNode(
-        'git-preprepare-pkg',
-        {
-          scripts: { preprepare: 'npm run setup' },
-        },
-      )
-      gitNodeWithPreprepare.id = joinDepIDTuple([
-        'git',
-        'github.com/user/repo2.git',
-        'git-preprepare-pkg@1.0.0',
-      ])
-
-      const gitNodeWithPostprepare = createTestNode(
-        'git-postprepare-pkg',
-        {
-          scripts: { postprepare: 'npm run cleanup' },
-        },
-      )
-      gitNodeWithPostprepare.id = joinDepIDTuple([
-        'git',
-        'github.com/user/repo3.git',
-        'git-postprepare-pkg@1.0.0',
-      ])
-
-      const gitNodeWithoutPrepare = createTestNode(
-        'git-no-prepare-pkg',
-        {},
-      )
-      gitNodeWithoutPrepare.id = joinDepIDTuple([
-        'git',
-        'github.com/user/repo4.git',
-        'git-no-prepare-pkg@1.0.0',
-      ])
-
-      const res = await scripts(
-        getState(':scripts', [
-          gitNodeWithPrepare,
-          gitNodeWithPreprepare,
-          gitNodeWithPostprepare,
-          gitNodeWithoutPrepare,
-        ]),
-      )
-
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['git-pkg', 'git-postprepare-pkg', 'git-preprepare-pkg'],
-        'should select git packages with prepare scripts',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects importer nodes with prepare scripts',
-    async t => {
-      const importerNodeWithPrepare = createTestNode('importer-pkg', {
-        scripts: { prepare: 'npm run build' },
-      })
-      importerNodeWithPrepare.importer = true
-
-      const importerNodeWithoutPrepare = createTestNode(
-        'importer-no-prepare-pkg',
-        {},
-      )
-      importerNodeWithoutPrepare.importer = true
-
-      const regularNodeWithPrepare = createTestNode('regular-pkg', {
-        scripts: { prepare: 'npm run build' },
-      })
-      // Add mock inVltStore method that returns true for regular nodes
-      ;(regularNodeWithPrepare as any).inVltStore = () => true
-
-      const res = await scripts(
-        getState(':scripts', [
-          importerNodeWithPrepare,
-          importerNodeWithoutPrepare,
-          regularNodeWithPrepare,
-        ]),
-      )
-
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['importer-pkg'],
-        'should select importer packages with prepare scripts but not regular packages in vlt store',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'filters out nodes without build requirements',
-    async t => {
-      const nodeWithoutManifest = createTestNode(
-        'no-manifest-pkg',
-        {},
-      )
-      delete nodeWithoutManifest.manifest
-
-      const nodeWithEmptyManifest = createTestNode(
-        'empty-manifest-pkg',
-        {},
-      )
-
-      const nodeWithOnlyDevScripts = createTestNode(
-        'dev-scripts-pkg',
-        {
-          scripts: {
-            dev: 'webpack serve',
-            test: 'jest',
-          },
-        },
-      )
-
-      const res = await scripts(
-        getState(':scripts', [
-          nodeWithoutManifest,
-          nodeWithEmptyManifest,
-          nodeWithOnlyDevScripts,
-        ]),
-      )
-
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        [],
-        'should filter out packages that do not need building',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test('selects nodes marked as needing a build', async t => {
-    // binding.gyp only: no scripts in package.json
-    const gyp = createTestNode('gyp-pkg', {})
-    gyp.buildState = 'needed'
-    const noManifest = createTestNode('no-manifest-pkg', {})
-    delete noManifest.manifest
-    noManifest.buildState = 'needed'
-    const built = createTestNode('built-pkg', {})
-    built.buildState = 'built'
-
-    const res = await scripts(
-      getState(':scripts', [gyp, noManifest, built]),
-    )
-
-    t.strictSame([...res.partial.nodes].map(n => n.name).sort(), [
-      'gyp-pkg',
-      'no-manifest-pkg',
-    ])
-  })
-
-  await t.test('handles mixed scenarios correctly', async t => {
-    const nodeNeedingBuild1 = createTestNode('build-pkg1', {
-      scripts: { install: 'make install' },
-    })
-
-    const nodeNeedingBuild2 = createTestNode('build-pkg2', {
-      scripts: { prepare: 'npm run compile' },
-    })
-    nodeNeedingBuild2.importer = true
-
-    const nodeNotNeedingBuild = createTestNode('no-build-pkg', {
-      scripts: { start: 'node server.js' },
-    })
-
-    const res = await scripts(
-      getState(':scripts', [
-        nodeNeedingBuild1,
-        nodeNeedingBuild2,
-        nodeNotNeedingBuild,
-      ]),
-    )
-
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name).sort(),
-      ['build-pkg1', 'build-pkg2'],
-      'should correctly handle mixed build scenarios',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name).sort(),
-      edges: [...res.partial.edges].map(e => e.name).sort(),
-    })
-  })
-
-  await t.test('handles empty partial state', async t => {
-    const state = getState(':scripts')
-    state.partial.nodes.clear()
-    state.partial.edges.clear()
-
-    const res = await scripts(state)
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      [],
-      'should return empty array when starting with empty partial state',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-})