Fix tests

Author: Septh

test/_common.ts

@@ -1,39 +1,42 @@
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import type { Plugin, RollupError, PluginContextMeta, NormalizedInputOptions } from 'rollup'
+import {
+    VERSION,
+    type Plugin, type RollupError, type PluginContextMeta, type NormalizedInputOptions
+} from 'rollup'
 import { nodeExternals, type ExternalsOptions } from '../source/index.ts'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 class MockPluginContext {
-    private readonly externals: Plugin
+    private readonly plugin: Plugin
     readonly warnings: string[]
     readonly meta: PluginContextMeta
 
-    constructor(externals: Plugin) {
-        this.externals = externals
+    constructor(plugin: Plugin) {
+        this.plugin = plugin
         this.warnings = []
         this.meta = {
-            rollupVersion: '4.9.6',
+            rollupVersion: VERSION,
             watchMode: false
         }
     }
 
     async buildStart() {
-        let { buildStart } = this.externals
-        if (typeof buildStart === 'object')
-            buildStart = buildStart.handler
-        if (typeof buildStart === 'function')
-            return await buildStart.call(this as any, {} as NormalizedInputOptions)
+        let { buildStart: hook } = this.plugin
+        if (typeof hook === 'object')
+            hook = hook.handler
+        if (typeof hook === 'function')
+            return await hook.call(this as any, {} as NormalizedInputOptions)
         throw new Error('Oops')
     }
 
-    async resolveId(specifier: string, importer: string | undefined) {
-        let { resolveId } = this.externals
-        if (typeof resolveId === 'object')
-            resolveId = resolveId.handler
-        if (typeof resolveId === 'function')
-            return await resolveId.call(this as any, specifier, importer, { attributes: {}, isEntry: typeof importer === 'string' ? false : true })
+    async resolveId(specifier: string, importer?: string | undefined) {
+        let { resolveId: hook } = this.plugin
+        if (typeof hook === 'object')
+            hook = hook.handler
+        if (typeof hook === 'function')
+            return await hook.call(this as any, specifier, importer, { attributes: {}, isEntry: typeof importer === 'string' ? false : true })
         throw new Error('Oops')
     }
 

test/fixtures/04_dual/package.json

@@ -1,8 +1,9 @@
 {
-  "devDependencies": {
+  "//": "Purposely marked both as a normal and a dev dependency",
+  "dependencies": {
     "dual-dep": "*"
   },
-  "peerDependencies": {
+  "devDependencies": {
     "dual-dep": "*"
   }
 }

test/specifier.test.ts

@@ -15,18 +15,18 @@ process.chdir(fixture())
 
 test("Always ignores bundle entry point", async t => {
     const context = await initPlugin()
-    t.is(await context.resolveId('./path/to/entry.js', undefined), null)
+    t.is(await context.resolveId('./path/to/entry.js'), null)
 })
 
 test("Always ignores virtual modules from other plugins", async t => {
     const context = await initPlugin()
-    t.is(await context.resolveId('\\0virtual', undefined), null, `Failed without importer`)
-    t.is(await context.resolveId('\\0virtual', 'file.js'), null, `Failed with importer`)
+    t.is(await context.resolveId(specifiers.virtual[0], undefined), null, `Failed without importer`)
+    t.is(await context.resolveId(specifiers.virtual[0], 'file.js'), null, `Failed with importer`)
 })
 
 test("Always ignores absolute specifiers", async t => {
     const context = await initPlugin()
-    for (const specifier of specifiers[process.platform === 'win32' ? 'absoluteWin32' : 'absolutePosix']) {
+    for (const specifier of (process.platform === 'win32' ? specifiers.absoluteWin32 : specifiers.absolutePosix)) {
         t.is(await context.resolveId(specifier, undefined), null, `Failed on: ${specifier} without importer`)
         t.is(await context.resolveId(specifier, 'file.js'), null, `Failed on: ${specifier} with importer`)
     }
@@ -47,7 +47,7 @@ test("Always ignores bare specifiers that are not dependencies", async t => {
 
 test("Marks dependencies external by default", async t => {
     const context = await initPlugin()
-    t.false(await context.resolveId('test-dep', 'index.js'))
+    t.is(await context.resolveId('test-dep', 'index.js'), false)
 })
 
 test("Does NOT mark dependencies external when deps=false", async t => {
@@ -62,32 +62,32 @@ test("Does NOT mark excluded dependencies external", async t => {
 
 test("Marks peerDependencies external by default", async t => {
     const context = await initPlugin()
-    t.is(await context.resolveId('test-dev-dep', 'index.js'), null)
+    t.is(await context.resolveId('test-peer-dep', 'index.js'), false)
 })
 
 test("Does NOT mark peerDependencies external when peerDeps=false", async t => {
     const context = await initPlugin({ peerDeps: false })
-    t.is(await context.resolveId('test-dev-dep', 'index.js'), null)
+    t.is(await context.resolveId('test-peer-dep', 'index.js'), null)
 })
 
 test("Does NOT mark excluded peerDependencies external", async t => {
     const context = await initPlugin({ exclude: 'test-peer-dep' })
-    t.is(await context.resolveId('test-dev-dep', 'index.js'), null)
+    t.is(await context.resolveId('test-peer-dep', 'index.js'), null)
 })
 
 test("Marks optionalDependencies external by default", async t => {
     const context = await initPlugin()
-    t.false(await context.resolveId('test-opt-dep', 'index.js'))
+    t.is(await context.resolveId('test-opt-dep', 'index.js'), false)
 })
 
 test("Does NOT mark optionalDependencies external when optDeps=false", async t => {
     const context = await initPlugin({ optDeps: false })
-    t.is(await context.resolveId('test-dev-dep', 'index.js'), null)
+    t.is(await context.resolveId('test-opt-dep', 'index.js'), null)
 })
 
 test("Does NOT mark excluded optionalDependencies external", async t => {
     const context = await initPlugin({ exclude: 'test-opt-dep' })
-    t.is(await context.resolveId('test-dev-dep', 'index.js'), null)
+    t.is(await context.resolveId('test-opt-dep', 'index.js'), null)
 })
 
 test("Does NOT mark devDependencies external by default", async t => {
@@ -97,30 +97,44 @@ test("Does NOT mark devDependencies external by default", async t => {
 
 test("Marks devDependencies external when devDeps=true", async t => {
     const context = await initPlugin({ devDeps: true })
-    t.false(await context.resolveId('test-dev-dep', 'index.js'))
+    t.is(await context.resolveId('test-dev-dep', 'index.js'), false)
 })
 
 test("Marks included devDependencies external", async t => {
     const context = await initPlugin({ include: 'test-dev-dep' })
-    t.false(await context.resolveId('test-dev-dep', 'index.js'))
+    t.is(await context.resolveId('test-dev-dep', 'index.js'), false)
 })
 
-test("Marks dependencies/peerDependencies/optionalDependencies subpath imports external", async t => {
+test("Subpath imports do not prevent dependencies/peerDependencies/optionalDependencies from being marked external", async t => {
     const context = await initPlugin()
     t.is(await context.resolveId('test-dep/sub',      'index.js'), false)
     t.is(await context.resolveId('test-peer-dep/sub', 'index.js'), false)
     t.is(await context.resolveId('test-opt-dep/sub',  'index.js'), false)
 })
 
-test("Marks subpath imports external (with regexes)", async t => {
+test("Marks both dependency and dependency/subpath as external (with regex)", async t => {
     const context = await initPlugin({ include: /^test-dev-dep/ })
     t.is(await context.resolveId('test-dev-dep',     'index.js'), false)
     t.is(await context.resolveId('test-dev-dep/sub', 'index.js'), false)
 })
 
-test("External dependencies have precedence over devDependencies", async t => {
-    const context = await initPlugin({
-        packagePath: '04_dual/package.json'
-    })
-    t.false(await context.resolveId('dual-dep', 'index.js'))
+test("exclude has precedence over include (builtins)", async t => {
+    const context = await initPlugin({ include: 'node:fs', exclude: 'node:fs' })
+    t.like(await context.resolveId('node:fs', 'index.js'), { external: false })
+})
+
+test("exclude has precedence over include (dependencies)", async t => {
+    const context = await initPlugin({ include: 'test-dep', exclude: 'test-dep' })
+    t.is(await context.resolveId('test-dep', 'index.js'), null)
+})
+
+test("exclude has precedence over include (with regexes)", async t => {
+    const context = await initPlugin({ devDeps: true, exclude: /^test-dev-dep\/sub/ })
+    t.is(await context.resolveId('test-dev-dep',     'index.js'), false)
+    t.is(await context.resolveId('test-dev-dep/sub', 'index.js'), null)
+})
+
+test("Normal dependencies have precedence over devDependencies", async t => {
+    const context = await initPlugin({ packagePath: '04_dual/package.json' })
+    t.is(await context.resolveId('dual-dep', 'index.js'), false)
 })