Windows

Author: aduh95

test/parallel/test-runner-module-mocking.js

@@ -154,7 +154,7 @@ test('CJS mocking with namedExports option', async (t) => {
     assert.strictEqual(original.string, 'original cjs string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${pathToFileURL(fixture)}`, {
       namedExports: { fn() { return 42; } },
     });
     const mocked = require(fixture);
@@ -174,7 +174,7 @@ test('CJS mocking with namedExports option', async (t) => {
     assert.strictEqual(original.string, 'original cjs string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${pathToFileURL(fixture)}`, {
       namedExports: { fn() { return 42; } },
       cache: true,
     });
@@ -195,7 +195,7 @@ test('CJS mocking with namedExports option', async (t) => {
     assert.strictEqual(original.string, 'original cjs string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${pathToFileURL(fixture)}`, {
       namedExports: { fn() { return 42; } },
       cache: false,
     });
@@ -219,7 +219,7 @@ test('CJS mocking with namedExports option', async (t) => {
 
     const defaultExport = { val1: 5, val2: 3 };
 
-    t.mock.module(fixture, {
+    t.mock.module(`${pathToFileURL(fixture)}`, {
       defaultExport,
       namedExports: { val1: 'mock value' },
     });
@@ -242,7 +242,7 @@ test('CJS mocking with namedExports option', async (t) => {
 
     const defaultExport = null;
 
-    t.mock.module(fixture, {
+    t.mock.module(`${pathToFileURL(fixture)}`, {
       defaultExport,
       namedExports: { val1: 'mock value' },
     });
@@ -256,13 +256,13 @@ test('CJS mocking with namedExports option', async (t) => {
 
 test('ESM mocking with namedExports option', async (t) => {
   await t.test('does not cache by default', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
     const original = await import(fixture);
 
     assert.strictEqual(original.string, 'original esm string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${fixture}`, {
       namedExports: { fn() { return 42; } },
     });
     const mocked = await import(fixture);
@@ -276,13 +276,13 @@ test('ESM mocking with namedExports option', async (t) => {
   });
 
   await t.test('explicitly enables caching', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
     const original = await import(fixture);
 
     assert.strictEqual(original.string, 'original esm string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${fixture}`, {
       namedExports: { fn() { return 42; } },
       cache: true,
     });
@@ -297,13 +297,13 @@ test('ESM mocking with namedExports option', async (t) => {
   });
 
   await t.test('explicitly disables caching', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
     const original = await import(fixture);
 
     assert.strictEqual(original.string, 'original esm string');
     assert.strictEqual(original.fn, undefined);
 
-    t.mock.module(fixture, {
+    t.mock.module(`${fixture}`, {
       namedExports: { fn() { return 42; } },
       cache: false,
     });
@@ -318,7 +318,8 @@ test('ESM mocking with namedExports option', async (t) => {
   });
 
   await t.test('named exports are not applied to defaultExport', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixturePath = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixture = pathToFileURL(fixturePath);
     const original = await import(fixture);
 
     assert.strictEqual(original.string, 'original esm string');
@@ -327,7 +328,7 @@ test('ESM mocking with namedExports option', async (t) => {
 
     const defaultExport = 'mock default';
 
-    t.mock.module(fixture, {
+    t.mock.module(`${fixture}`, {
       defaultExport,
       namedExports: { val1: 'mock value' },
     });
@@ -338,19 +339,19 @@ test('ESM mocking with namedExports option', async (t) => {
     assert.strictEqual(mocked.default, 'mock default');
     assert.strictEqual(mocked.val1, 'mock value');
     t.mock.reset();
-    common.expectRequiredModule(require(fixture), original);
+    common.expectRequiredModule(require(fixturePath), original);
   });
 
   await t.test('throws if named exports cannot be applied to defaultExport as CJS', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-cjs.js');
+    const fixture = fixtures.fileURL('module-mocking', 'basic-cjs.js');
     const original = await import(fixture);
 
     assert.strictEqual(original.default.string, 'original cjs string');
     assert.strictEqual(original.default.val1, undefined);
 
     const defaultExport = null;
 
-    t.mock.module(fixture, {
+    t.mock.module(`${fixture}`, {
       defaultExport,
       namedExports: { val1: 'mock value' },
     });
@@ -366,13 +367,14 @@ test('ESM mocking with namedExports option', async (t) => {
 test('modules cannot be mocked multiple times at once', async (t) => {
   await t.test('CJS', async (t) => {
     const fixture = fixtures.path('module-mocking', 'basic-cjs.js');
+    const fixtureURL = pathToFileURL(fixture).href;
 
-    t.mock.module(fixture, {
+    t.mock.module(fixtureURL, {
       namedExports: { fn() { return 42; } },
     });
 
     assert.throws(() => {
-      t.mock.module(fixture, {
+      t.mock.module(fixtureURL, {
         namedExports: { fn() { return 55; } },
       });
     }, {
@@ -386,7 +388,7 @@ test('modules cannot be mocked multiple times at once', async (t) => {
   });
 
   await t.test('ESM', async (t) => {
-    const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+    const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs').href;
 
     t.mock.module(fixture, {
       namedExports: { fn() { return 42; } },
@@ -405,14 +407,20 @@ test('modules cannot be mocked multiple times at once', async (t) => {
 
     assert.strictEqual(mocked.fn(), 42);
   });
+
+  await t.test('Importing a Windows path should fail', { skip: common.isWindows }, async (t) => {
+    const fixture = fixtures.path('module-mocking', 'wrong-path.js');
+    t.mock.module(fixture, { namedExports: { fn() { return 42; } } });
+    await assert.rejects(import(fixture), { code: 'ERR_UNSUPPORTED_ESM_URL_SCHEME' });
+  })
 });
 
 test('mocks are automatically restored', async (t) => {
   const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js');
-  const esmFixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+  const esmFixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
 
   await t.test('CJS', async (t) => {
-    t.mock.module(cjsFixture, {
+    t.mock.module(`${pathToFileURL(cjsFixture)}`, {
       namedExports: { fn() { return 42; } },
     });
 
@@ -422,7 +430,7 @@ test('mocks are automatically restored', async (t) => {
   });
 
   await t.test('ESM', async (t) => {
-    t.mock.module(esmFixture, {
+    t.mock.module(`${esmFixture}`, {
       namedExports: { fn() { return 43; } },
     });
 
@@ -442,13 +450,13 @@ test('mocks are automatically restored', async (t) => {
 
 test('mocks can be restored independently', async (t) => {
   const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js');
-  const esmFixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+  const esmFixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
 
-  const cjsMock = t.mock.module(cjsFixture, {
+  const cjsMock = t.mock.module(`${pathToFileURL(cjsFixture)}`, {
     namedExports: { fn() { return 42; } },
   });
 
-  const esmMock = t.mock.module(esmFixture, {
+  const esmMock = t.mock.module(`${esmFixture}`, {
     namedExports: { fn() { return 43; } },
   });
 
@@ -511,18 +519,19 @@ test('node:- core module mocks can be used by both module systems', async (t) =>
 
 test('CJS mocks can be used by both module systems', async (t) => {
   const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js');
-  const cjsMock = t.mock.module(cjsFixture, {
+  const cjsFixtureURL = pathToFileURL(cjsFixture)
+  const cjsMock = t.mock.module(`${cjsFixtureURL}`, {
     namedExports: { fn() { return 42; } },
   });
-  let esmImpl = await import(cjsFixture);
+  let esmImpl = await import(cjsFixtureURL);
   let cjsImpl = require(cjsFixture);
 
   assert.strictEqual(esmImpl.fn(), 42);
   assert.strictEqual(cjsImpl.fn(), 42);
 
   cjsMock.restore();
 
-  esmImpl = await import(cjsFixture);
+  esmImpl = await import(cjsFixtureURL);
   cjsImpl = require(cjsFixture);
 
   assert.strictEqual(esmImpl.default.string, 'original cjs string');
@@ -531,19 +540,20 @@ test('CJS mocks can be used by both module systems', async (t) => {
 
 test('ESM mocks can be used by both module systems', async (t) => {
   const esmFixture = fixtures.path('module-mocking', 'basic-esm.mjs');
-  const esmMock = t.mock.module(esmFixture, {
+  const esmFixtureURL = pathToFileURL(esmFixture)
+  const esmMock = t.mock.module(`${esmFixtureURL}`, {
     namedExports: { fn() { return 42; } },
   });
 
   let cjsImpl = require(esmFixture);
-  let esmImpl = await import(esmFixture);
+  let esmImpl = await import(esmFixtureURL);
 
   assert.strictEqual(cjsImpl.fn(), 42);
   assert.strictEqual(esmImpl.fn(), 42);
 
   esmMock.restore();
   cjsImpl = require(esmFixture);
-  esmImpl = await import(esmFixture);
+  esmImpl = await import(esmFixtureURL);
 
   assert.strictEqual(esmImpl.string, 'original esm string');
   assert.strictEqual(cjsImpl.string, 'original esm string');
@@ -552,7 +562,7 @@ test('ESM mocks can be used by both module systems', async (t) => {
 test('relative paths can be used by both module systems', async (t) => {
   const fixture = relative(
     __dirname, fixtures.path('module-mocking', 'basic-esm.mjs')
-  );
+  ).replaceAll('\\', '/');
   const mock = t.mock.module(fixture, {
     namedExports: { fn() { return 42; } },
   });
@@ -604,9 +614,9 @@ test('file:// imports are supported in ESM only', async (t) => {
 });
 
 test('mocked modules do not impact unmocked modules', async (t) => {
-  const mockedFixture = fixtures.path('module-mocking', 'basic-cjs.js');
-  const unmockedFixture = fixtures.path('module-mocking', 'basic-esm.mjs');
-  t.mock.module(mockedFixture, {
+  const mockedFixture = fixtures.fileURL('module-mocking', 'basic-cjs.js');
+  const unmockedFixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs');
+  t.mock.module(`${mockedFixture}`, {
     namedExports: { fn() { return 42; } },
   });
   const mockedImpl = await import(mockedFixture);
@@ -619,24 +629,26 @@ test('mocked modules do not impact unmocked modules', async (t) => {
 
 test('defaultExports work with CJS mocks in both module systems', async (t) => {
   const fixture = fixtures.path('module-mocking', 'basic-cjs.js');
+  const fixtureURL = pathToFileURL(fixture);
   const original = require(fixture);
   const defaultExport = Symbol('default');
 
   assert.strictEqual(original.string, 'original cjs string');
-  t.mock.module(fixture, { defaultExport });
+  t.mock.module(`${fixtureURL}`, { defaultExport });
   assert.strictEqual(require(fixture), defaultExport);
-  assert.strictEqual((await import(fixture)).default, defaultExport);
+  assert.strictEqual((await import(fixtureURL)).default, defaultExport);
 });
 
 test('defaultExports work with ESM mocks in both module systems', async (t) => {
-  const fixture = fixtures.path('module-mocking', 'basic-esm.mjs');
+  const fixturePath = fixtures.path('module-mocking', 'basic-esm.mjs');
+  const fixture = pathToFileURL(fixturePath);
   const original = await import(fixture);
   const defaultExport = Symbol('default');
 
   assert.strictEqual(original.string, 'original esm string');
-  t.mock.module(fixture, { defaultExport });
+  t.mock.module(`${fixture}`, { defaultExport });
   assert.strictEqual((await import(fixture)).default, defaultExport);
-  assert.strictEqual(require(fixture), defaultExport);
+  assert.strictEqual(require(fixturePath), defaultExport);
 });
 
 test('wrong import syntax should throw error after module mocking.', async () => {