feat: drop support of async mock factory

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.2.2/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.2.4/schema.json",
   "assist": { "actions": { "source": { "organizeImports": "on" } } },
   "vcs": {
     "enabled": true,
@@ -70,5 +70,27 @@
         "useHookAtTopLevel": "off"
       }
     }
-  }
+  },
+  "overrides": [
+    {
+      "includes": ["e2e/mock/tests/mockHoist.test.ts"],
+      "assist": {
+        "actions": {
+          "source": {
+            "organizeImports": "off"
+          }
+        }
+      }
+    },
+    {
+      "includes": ["e2e/__mocks__/is-url.js", "e2e/__mocks__/redux-cjs.ts"],
+      "linter": {
+        "rules": {
+          "style": {
+            "useFilenamingConvention": "off"
+          }
+        }
+      }
+    }
+  ]
 }

e2e/__mocks__/is-url.js

@@ -0,0 +1,4 @@
+const { rs } = require('@rstest/core');
+
+module.exports = () => 'is-url mock';
+module.exports.fn = rs.fn();

e2e/__mocks__/redux-cjs.ts

@@ -0,0 +1,6 @@
+const { rs } = require('@rstest/core');
+
+module.exports = {
+  isAction: rs.fn(),
+  mocked: 'redux_yes',
+};

e2e/basic/test/index.test.ts

@@ -24,8 +24,8 @@ describe('Index', () => {
   });
 
   it('should use require.resolve correctly', async () => {
-    expect(
-      require.resolve('../src/index.ts').endsWith('index.ts'),
-    ).toBeTruthy();
+    const resolved = require.resolve('../src/index.ts');
+    // TODO: can't write as  require.resolve('../src/index.ts').endsWith('index.ts')
+    expect(resolved.endsWith('index.ts')).toBeTruthy();
   });
 });

e2e/dom/fixtures/package.json

@@ -12,7 +12,7 @@
     "react-dom": "^19.1.1"
   },
   "devDependencies": {
-    "@rsbuild/core": "1.5.0",
+    "@rsbuild/core": "1.6.0-beta.0",
     "@rsbuild/plugin-react": "^1.4.0",
     "@testing-library/jest-dom": "^6.8.0",
     "@testing-library/dom": "^10.4.1",

e2e/lifecycle/timeout.test.ts

@@ -34,7 +34,7 @@ describe('test timeout', () => {
       ),
     ).toBeTruthy();
     expect(
-      logs.find((log) => log.includes('timeout.test.ts:4:10')),
+      logs.find((log) => log.includes('timeout.test.ts:4:1')),
     ).toBeTruthy();
     expect(
       logs.find((log) => log.includes('Test Files 1 failed')),

e2e/mock/src/bar.ts

@@ -0,0 +1 @@
+export const bar = 'bar';

e2e/mock/src/baz.ts

@@ -0,0 +1 @@
+export const baz = 'baz';

e2e/mock/src/d.ts

@@ -1 +1,3 @@
-export const d: number = 4;
+export const d1: number = 1;
+export const d2: number = 2;
+export const d3: number = 3;

e2e/mock/src/foo.ts

@@ -0,0 +1 @@
+export const foo = 'foo';

e2e/mock/src/readSomeFile.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from 'node:fs';
+import * as fs from 'node:fs';
 
 export function readSomeFile(path: string) {
-  return readFileSync(path, 'utf-8');
+  return fs?.readFileSync?.(path, 'utf-8');
 }

e2e/mock/src/sum.ts

@@ -0,0 +1,4 @@
+import { bar } from './bar';
+import { foo } from './foo';
+
+export const sum = foo + bar;

e2e/mock/tests/barrel.test.ts

@@ -0,0 +1,11 @@
+import { expect, it, rs } from '@rstest/core';
+import { baz } from '../src/baz';
+import { sum } from '../src/sum';
+
+rs.mock('../src/foo', () => {
+  return { foo: baz };
+});
+
+it('sum', () => {
+  expect(sum).toBe('bazbar');
+});

e2e/mock/tests/doMock.test.ts

@@ -1,5 +1,4 @@
 import { expect, rs, test } from '@rstest/core';
-import { sleep } from '../../scripts/utils';
 
 test('doMock works', async () => {
   const { increment: incrementWith1 } = await import('../src/increment');
@@ -32,8 +31,7 @@ test('the second doMock can override the first doMock', async () => {
 });
 
 test('the third doMock can override the second doMock', async () => {
-  rs.doMock('../src/increment', async () => {
-    await sleep(500);
+  rs.doMock('../src/increment', () => {
     return {
       increment: (num: number) => num + 100,
     };
@@ -43,8 +41,7 @@ test('the third doMock can override the second doMock', async () => {
 
   expect(incrementWith1(1)).toBe(101);
 
-  rs.doMock('../src/increment', async () => {
-    await sleep(500);
+  rs.doMock('../src/increment', () => {
     return {
       increment: (num: number) => num + 200,
     };

e2e/mock/tests/doMockRequire.test.ts

@@ -9,7 +9,6 @@ test('doMockRequire works', () => {
   }));
 
   const { increment: incrementWith10 } = require('../src/increment');
-
   expect(incrementWith10(1)).toBe(11);
 });
 
@@ -30,3 +29,25 @@ test('the second doMockRequire can override the first doMockRequire', () => {
 
   expect(incrementWith20(1)).toBe(21);
 });
+
+test('the third doMockRequire can override the second doMockRequire', () => {
+  rs.doMockRequire('../src/increment', () => {
+    return {
+      increment: (num: number) => num + 100,
+    };
+  });
+
+  const { increment: incrementWith1 } = require('../src/increment');
+
+  expect(incrementWith1(1)).toBe(101);
+
+  rs.doMockRequire('../src/increment', () => {
+    return {
+      increment: (num: number) => num + 200,
+    };
+  });
+
+  const { increment: incrementWith20 } = require('../src/increment');
+
+  expect(incrementWith20(1)).toBe(201);
+});

e2e/mock/tests/importActual.test.ts

@@ -1,6 +1,10 @@
 import { expect, it, rs } from '@rstest/core';
+import axiosActual from 'axios' with { rstest: 'importActual' };
 import axios from 'axios';
+import { b as bActual } from '../src/b' with { rstest: 'importActual' };
+import { b } from '../src/b';
 
+// #region axios
 rs.mock('axios');
 
 it('mocked axios (axios is externalized)', async () => {
@@ -11,10 +15,38 @@ it('mocked axios (axios is externalized)', async () => {
   expect(axios.post).toBeUndefined();
 });
 
-it('use `importActual` to import actual axios', async () => {
-  const ax = await rs.importActual<typeof axios>('axios');
-  expect(rs.isMockFunction(ax.get)).toBe(false);
+it('use `importActual` attributes to import actual axios', () => {
+  expect(rs.isMockFunction(axiosActual.get)).toBe(false);
   // @ts-expect-error
-  expect(ax.mocked).toBeUndefined();
-  expect(typeof ax.AxiosHeaders).toBe('function');
+  expect(axiosActual.mocked).toBeUndefined();
+  expect(typeof axiosActual.AxiosHeaders).toBe('function');
 });
+
+it('use `rs.importActual` to import actual axios', async () => {
+  const axiosRsActual = await rs.importActual<typeof axios>('axios');
+  expect(rs.isMockFunction(axiosRsActual.get)).toBe(false);
+  // @ts-expect-error
+  expect(axiosRsActual.mocked).toBeUndefined();
+  expect(typeof axiosRsActual.AxiosHeaders).toBe('function');
+});
+// #endregion
+
+// #region ../src/b
+rs.mock('../src/b', () => {
+  return { b: 'b_mocked' };
+});
+
+it('mocked ../src/b', () => {
+  expect(b).toBe('b_mocked');
+});
+
+it('use `importActual` to import actual ../src/b', () => {
+  expect(bActual).toBe(2);
+});
+
+it('use `rs.importActual` to import actual ../src/b', async () => {
+  const { b: bRsActual } =
+    await rs.importActual<typeof import('../src/b')>('../src/b');
+  expect(bRsActual).toBe(2);
+});
+// #endregion

e2e/mock/tests/importMock.test.ts

@@ -0,0 +1,12 @@
+import { expect, rs, test } from '@rstest/core';
+import * as redux from 'redux';
+
+test('importMock works', async () => {
+  const { default: redux } = await rs.importMock<any>('redux');
+  await redux.isAction('string');
+  expect(redux.isAction).toHaveBeenCalledWith('string');
+});
+
+test('actual redux is not mocked (ESM)', async () => {
+  expect(rs.isMockFunction(redux.isAction)).toBe(false);
+});

e2e/mock/tests/mock.test.ts

@@ -1,45 +1,53 @@
 import { expect, it, rs } from '@rstest/core';
+import * as originalAxios from 'axios' with { rstest: 'importActual' };
+import * as axios from 'axios';
 import redux from 'redux';
-import { sleep } from '../../scripts/utils';
-import { d } from '../src/d';
+import { d1, d2 } from '../src/d' with { rstest: 'importActual' };
+import { d3 } from '../src/d';
 
 // To test async mocking factory.
-rs.mock('../src/d', async () => {
-  await sleep(1000);
+rs.mock('../src/d', () => {
   return {
-    d: rs.fn(),
+    d1,
+    d2,
+    d3: rs.fn(),
   };
 });
 
-it('mocked d', async () => {
+it('mocked d', () => {
   // @ts-expect-error: It has been mocked.
-  d('string1');
-  expect(d).toHaveBeenCalledWith('string1');
+  d3('string1');
+  expect(d3).toHaveBeenCalledWith('string1');
+  expect(d1).toBe(1);
+  expect(d2).toBe(2);
 });
 
 // manual mock
 rs.mock('redux');
 
-it('mocked redux', async () => {
+it('mocked redux', () => {
   redux.isAction('string');
   expect(redux.isAction).toHaveBeenCalledWith('string');
   // @ts-expect-error: It has been mocked.
   expect(redux.mocked).toBe('redux_yes');
 });
 
 // mock factory
-rs.mock('axios', async () => {
-  const originalAxios = await rs.importActual('axios');
+rs.mock('axios', () => {
+  // partial mock
   return {
     ...originalAxios,
-    post: rs.fn(),
+    aaa: rs.fn(),
   };
 });
 
 it('mocked axios', async () => {
-  const axios = await import('axios');
   // @ts-expect-error
-  expect(rs.isMockFunction(axios.post)).toBe(true);
+  expect(rs.isMockFunction(axios.aaa)).toBe(true);
   // @ts-expect-error
-  expect(rs.isMockFunction(axios.get)).toBe(false);
+  expect(rs.isMockFunction(axios.bbb)).toBe(false);
+  // @ts-expect-error
+  expect(originalAxios.aaa).toBeUndefined();
+  // @ts-expect-error
+  expect(originalAxios.bbb).toBeUndefined();
 });

e2e/mock/tests/mockHoist.test.ts

@@ -1,17 +1,19 @@
 import { expect, it, rs } from '@rstest/core';
-import { c } from '../src/c';
-import { d } from '../src/d';
+// NOTE: '../src/d' MUST imported ahead of '../src/c' to avoid circular dependency
+import { d1 } from '../src/d';
+// @ts-expect-error
+import { c, dd } from '../src/c';
+
+it('mocked c', async () => {
+  // @ts-expect-error
+  c('c');
+  expect(c).toHaveBeenCalledWith('c');
+  expect(dd).toBe(1);
+});
 
 rs.mock('../src/c', () => {
   return {
     c: rs.fn(),
-    d,
+    dd: d1,
   };
 });
-
-it('mocked c', async () => {
-  // @ts-expect-error: It has been mocked.
-  c('c');
-  expect(c).toHaveBeenCalledWith('c');
-  expect(d).toBe(4);
-});

e2e/mock/tests/mockRequire.test.ts

@@ -1,10 +1,10 @@
 import { expect, it, rs } from '@rstest/core';
 
-rs.mockRequire('redux');
+rs.mockRequire('is-url');
 
-it('mocked redux', () => {
-  const redux = require('redux').default;
-  redux.isAction('string');
-  expect(redux.isAction).toHaveBeenCalledWith('string');
-  expect(redux.mocked).toBe('redux_yes');
+it('mocked is-url', () => {
+  const isUrl = require('is-url');
+  isUrl.fn('string');
+  expect(isUrl.fn).toHaveBeenCalledWith('string');
+  expect(isUrl()).toBe('is-url mock');
 });