@modern-js/core 1.2.1-rc.0 → 1.4.0

package/tests/config.test.ts

@@ -0,0 +1,137 @@
+import path from 'path';
+// import os from 'os';
+import { isDev, getPort } from '@modern-js/utils';
+import { resolveConfig } from '../src/config';
+import {
+  cli,
+  loadUserConfig,
+  initAppContext,
+  initAppDir,
+  manager,
+  createPlugin,
+  registerHook,
+  useRunner,
+} from '../src';
+import { defaults } from '../src/config/defaults';
+
+jest.mock('@modern-js/utils', () => ({
+  __esModule: true,
+  ...jest.requireActual('@modern-js/utils'),
+  isDev: jest.fn(),
+  getPort: jest.fn(),
+}));
+
+// const kOSRootDir =
+//   os.platform() === 'win32' ? process.cwd().split(path.sep)[0] : '/';
+
+describe('config', () => {
+  /**
+   * Typescript Type annotations cannot be used for esbuild-jest
+   * test files that use jest.mock('@some/module')
+   * refer to this esbuild-jest issue:
+   * https://github.com/aelbore/esbuild-jest/issues/57
+   * TODO: find a better solution to solve this problem while allowing us
+   * to use esbuild, and have good TypeScript support
+   */
+  let loaded = {
+    config: {},
+    filePath: '',
+    dependencies: [],
+    pkgConfig: {},
+    jsConfig: {},
+  };
+  let schemas: any[] = [];
+  let restartWithExistingPort = 0;
+  let argv: string[] = ['dev'];
+  let configs: any[] = [];
+
+  const getResolvedConfig = async () =>
+    resolveConfig(loaded, configs, schemas, restartWithExistingPort, argv);
+
+  const resetParams = () => {
+    loaded = {
+      config: {},
+      filePath: '',
+      dependencies: [],
+      pkgConfig: {},
+      jsConfig: {},
+    };
+    schemas = [];
+    restartWithExistingPort = 0;
+    argv = ['dev'];
+    configs = [];
+  };
+  const resetMock = () => {
+    jest.resetAllMocks();
+    (isDev as jest.Mock).mockReturnValue(true);
+    (getPort as jest.Mock).mockReturnValue(
+      Promise.resolve(defaults.server.port),
+    );
+  };
+  beforeEach(() => {
+    resetParams();
+    resetMock();
+  });
+
+  it('default', () => {
+    expect(resolveConfig).toBeDefined();
+    expect(cli).toBeDefined();
+    expect(loadUserConfig).toBeDefined();
+    expect(initAppContext).toBeDefined();
+    expect(initAppDir).toBeDefined();
+    expect(manager).toBeDefined();
+    expect(createPlugin).toBeDefined();
+    expect(registerHook).toBeDefined();
+    expect(useRunner).toBeDefined();
+  });
+
+  it('initAppDir', async () => {
+    expect(await initAppDir(__dirname)).toBe(path.resolve(__dirname, '..'));
+    // expect(await initAppDir()).toBe(path.resolve(__dirname, '..'));
+
+    // FIXME: windows 下面会失败，先忽略这个测试
+    // try {
+    //   await initAppDir(kOSRootDir);
+    //   expect(true).toBe(false); // SHOULD NOT BE HERE
+    // } catch (err: any) {
+    //   expect(err.message).toMatch(/no package.json found in current work dir/);
+    // }
+  });
+
+  test('should use default port if not restarting in dev mode', async () => {
+    let resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(defaults.server.port);
+    expect(getPort).toHaveBeenCalledWith(defaults.server.port);
+
+    // getResolvedConfig should use the value givin by getPort
+    restartWithExistingPort = -1;
+    (getPort as jest.Mock).mockClear();
+    (getPort as jest.Mock).mockReturnValue(1111);
+    resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(1111);
+    expect(getPort).toHaveBeenCalledWith(defaults.server.port);
+
+    argv = ['start'];
+    (isDev as jest.Mock).mockReturnValue(false);
+    restartWithExistingPort = 0;
+    resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(defaults.server.port);
+
+    restartWithExistingPort = 1234;
+    resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(defaults.server.port);
+
+    restartWithExistingPort = -1;
+    resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(defaults.server.port);
+  });
+
+  test('should reuse existing port if restarting in dev mode', async () => {
+    restartWithExistingPort = 1234;
+    const resolved = await getResolvedConfig();
+    expect(resolved.server.port).toEqual(1234);
+  });
+});
+
+// type TEST = Parameters<typeof resolveConfig>;
+// type TypeC = TEST[1];

package/tests/context.test.ts

@@ -0,0 +1,68 @@
+import path from 'path';
+import { initAppContext } from '../src/context';
+
+describe('context', () => {
+  it('initAppContext', () => {
+    const appDirectory = path.resolve(
+      __dirname,
+      './fixtures/load-plugin/user-plugins',
+    );
+    const appContext = initAppContext(appDirectory, [], false);
+    expect(appContext).toEqual({
+      appDirectory,
+      configFile: false,
+      ip: expect.any(String),
+      port: 0,
+      packageName: expect.any(String),
+      srcDirectory: expect.any(String),
+      distDirectory: expect.any(String),
+      sharedDirectory: expect.any(String),
+      nodeModulesDirectory: expect.any(String),
+      internalDirectory: expect.any(String),
+      plugins: [],
+      htmlTemplates: {},
+      serverRoutes: [],
+      entrypoints: [],
+      existSrc: true,
+      internalDirAlias: '@_modern_js_internal',
+      internalSrcAlias: '@_modern_js_src',
+      metaName: 'modern-js',
+    });
+  });
+
+  it('custom AppContext', () => {
+    const appDirectory = path.resolve(
+      __dirname,
+      './fixtures/load-plugin/user-plugins',
+    );
+
+    const customOptions = {
+      srcDir: 'source',
+      distDir: 'dist',
+      sharedDir: 'myShared',
+      metaName: 'jupiter',
+    };
+
+    const appContext = initAppContext(appDirectory, [], false, customOptions);
+    expect(appContext).toEqual({
+      appDirectory,
+      configFile: false,
+      ip: expect.any(String),
+      port: 0,
+      packageName: 'user-plugins',
+      srcDirectory: path.resolve(appDirectory, './source'),
+      distDirectory: 'dist',
+      sharedDirectory: path.resolve(appDirectory, './myShared'),
+      nodeModulesDirectory: expect.any(String),
+      internalDirectory: path.resolve(appDirectory, './node_modules/.jupiter'),
+      plugins: [],
+      htmlTemplates: {},
+      serverRoutes: [],
+      entrypoints: [],
+      existSrc: true,
+      internalDirAlias: '@_jupiter_internal',
+      internalSrcAlias: '@_jupiter_src',
+      metaName: 'jupiter',
+    });
+  });
+});

package/tests/fixtures/index-test/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "index-test"
+}

package/tests/index.test.ts

@@ -0,0 +1,74 @@
+import path from 'path';
+import { cli } from '../src';
+import { resolveConfig, loadUserConfig } from '../src/config';
+import { loadEnv } from '../src/loadEnv';
+
+jest.mock('../src/config', () => ({
+  __esModule: true,
+  ...jest.requireActual('../src/config'),
+  loadUserConfig: jest.fn(),
+  resolveConfig: jest.fn(),
+}));
+
+jest.mock('../src/loadEnv', () => ({
+  __esModule: true,
+  ...jest.requireActual('../src/loadEnv'),
+  loadEnv: jest.fn(),
+}));
+
+describe('@modern-js/core test', () => {
+  let mockResolveConfig: any = {};
+  let mockLoadedConfig: any = {};
+  const cwdSpy = jest.spyOn(process, 'cwd');
+  const cwd = path.join(__dirname, './fixtures/index-test');
+
+  const resetMock = () => {
+    jest.resetAllMocks();
+    cwdSpy.mockReturnValue(cwd);
+    (resolveConfig as jest.Mock).mockReturnValue(
+      Promise.resolve(mockResolveConfig),
+    );
+    (loadUserConfig as jest.Mock).mockImplementation(() =>
+      Promise.resolve(mockLoadedConfig),
+    );
+  };
+
+  const resetValues = () => {
+    mockLoadedConfig = {
+      config: {},
+      filePath: false,
+      dependencies: [],
+      pkgConfig: {},
+      jsConfig: {},
+    };
+    mockResolveConfig = {
+      server: {
+        port: 8080,
+      },
+      output: {
+        path: './my/test/path',
+      },
+    };
+  };
+
+  beforeEach(() => {
+    resetValues();
+    resetMock();
+  });
+
+  it('test cli create', () => {
+    expect(cli).toBeTruthy();
+  });
+
+  it('test cli init dev', async () => {
+    cwdSpy.mockReturnValue(path.join(cwd, 'nested-folder'));
+    const options = {
+      beforeUsePlugins: jest.fn(),
+    };
+    options.beforeUsePlugins.mockImplementation((plugins, _) => plugins);
+    await cli.init(['dev'], options);
+    expect(loadEnv).toHaveBeenCalledWith(cwd);
+    expect(options.beforeUsePlugins).toHaveBeenCalledWith([], {});
+    // TODO: add more test cases
+  });
+});

package/tests/initWatcher.test.ts

@@ -0,0 +1,63 @@
+import * as path from 'path';
+import { fs, wait } from '@modern-js/utils';
+import { initWatcher } from '../src/initWatcher';
+
+jest.useRealTimers();
+
+const mockAppDirectory = path.join(__dirname, './fixtures/index-test');
+const mockConfigDir = './config';
+const mockSrcDirectory = path.join(mockAppDirectory, './src');
+
+describe('initWatcher', () => {
+  afterAll(() => {
+    const file = path.join(mockSrcDirectory, './index.ts');
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+    }
+  });
+
+  test('will trigger add event', async () => {
+    let triggeredType = '';
+    let triggeredFile = '';
+    const loaded = {
+      filePath: '',
+      dependencies: [],
+    };
+    const hooksRunner = {
+      watchFiles: async () => [mockSrcDirectory],
+      fileChange: jest.fn(({ filename, eventType }) => {
+        triggeredType = eventType;
+        triggeredFile = filename;
+      }),
+    };
+
+    if (await fs.pathExists(mockSrcDirectory)) {
+      await fs.remove(mockSrcDirectory);
+    }
+
+    const watcher = await initWatcher(
+      loaded as any,
+      mockAppDirectory,
+      mockConfigDir,
+      hooksRunner as any,
+      ['dev'],
+    );
+    await wait(100);
+
+    const file = path.join(mockSrcDirectory, './index.ts');
+    await fs.outputFile(file, '');
+    await wait(100);
+    // expect(hooksRunner.fileChange).toBeCalledTimes(1);
+    expect(triggeredType).toBe('add');
+    expect(file.includes(triggeredFile)).toBeTruthy();
+
+    await wait(100);
+    await fs.remove(file);
+    await wait(200);
+    expect(hooksRunner.fileChange).toBeCalledTimes(2);
+    expect(triggeredType).toBe('unlink');
+    expect(file.includes(triggeredFile)).toBeTruthy();
+
+    watcher?.close();
+  });
+});

package/tests/loadEnv.test.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { loadEnv } from '@/loadEnv';
+import { loadEnv } from '../src/loadEnv';
 
 const fixture = path.resolve(__dirname, './fixtures/load-env');
 

package/tests/loadPlugin.test.ts

@@ -1,7 +1,21 @@
 import path from 'path';
-import { loadPlugins } from '@/loadPlugins';
+import { loadPlugins, getAppPlugins } from '../src/loadPlugins';
 
 describe('load plugins', () => {
+  test('getAppPlugins', () => {
+    const appDirectory = path.resolve(
+      __dirname,
+      './fixtures/load-plugin/user-plugins',
+    );
+    const plugins = getAppPlugins(appDirectory, ['foo' as any], {
+      x: {
+        cli: 'x',
+        forced: true,
+      } as any,
+    });
+    expect(plugins).toEqual([{ cli: 'x', forced: true }, 'foo']);
+  });
+
   test('should load user plugin successfully', () => {
     const fixture = path.resolve(
       __dirname,
@@ -23,7 +37,6 @@ describe('load plugins', () => {
       },
       {
         server: {
-          name: 'b',
           pluginPath: path.join(fixture, './test-plugin-b.js'),
         },
         serverPath: './test-plugin-b',
@@ -31,6 +44,27 @@ describe('load plugins', () => {
     ]);
   });
 
+  test('should load user string plugin successfully', () => {
+    const fixture = path.resolve(
+      __dirname,
+      './fixtures/load-plugin/user-plugins',
+    );
+
+    const plugins = loadPlugins(fixture, [
+      path.join(fixture, './test-plugin-a.js') as any,
+    ]);
+
+    expect(plugins).toEqual([
+      {
+        cli: {
+          name: 'a',
+          pluginPath: path.join(fixture, './test-plugin-a.js'),
+        },
+        cliPath: path.join(fixture, './test-plugin-a.js'),
+      },
+    ]);
+  });
+
   test(`should throw error when plugin not found `, () => {
     const fixture = path.resolve(__dirname, './fixtures/load-plugin/not-found');
 

package/tests/mergeConfig.test.ts

@@ -1,4 +1,4 @@
-import { mergeConfig } from '@/config/mergeConfig';
+import { mergeConfig } from '../src/config/mergeConfig';
 
 describe('load plugins', () => {
   test('should replace property deeply', () => {

package/tests/repeatKeyWarning.test.ts

@@ -1,5 +1,5 @@
-import { repeatKeyWarning } from '@/utils/repeatKeyWarning';
-import { UserConfig } from '@/config';
+import { repeatKeyWarning } from '../src/utils/repeatKeyWarning';
+import { UserConfig } from '../src/config';
 
 jest.spyOn(process, 'exit').mockImplementation();
 

package/tests/schema.test.ts

@@ -1,4 +1,4 @@
-import { patchSchema, traverseSchema } from '@/config/schema';
+import { patchSchema, traverseSchema } from '../src/config/schema';
 
 describe('patch schemas', () => {
   test('should add schema succcessfully', () => {

package/tests/tsconfig.json

@@ -6,8 +6,6 @@
     "baseUrl": "./",
     "isolatedModules": true,
     "esModuleInterop": true,
-    "paths": {
-      "@/*": ["../src/*"]
-    }
+    "paths": {}
   }
 }

package/tests/utils.test.ts

@@ -0,0 +1,8 @@
+import { program, Command } from '../src/utils/commander';
+
+describe('utils', () => {
+  it('default', () => {
+    expect(program).toBeDefined();
+    expect(Command).toBeDefined();
+  });
+});

package/tsconfig.json

@@ -6,9 +6,7 @@
     "baseUrl": "./",
     "isolatedModules": true,
     "esModuleInterop": true,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
+    "paths": {}
   },
   "include": ["src"]
 }

package/src/config/defaults.ts

@@ -1,101 +0,0 @@
-import { OutputConfig, ServerConfig, SourceConfig } from '.';
-
-const sourceDefaults: SourceConfig = {
-  entries: undefined,
-  disableDefaultEntries: false,
-  entriesDir: './src',
-  configDir: './config',
-  apiDir: './api',
-  envVars: [],
-  globalVars: undefined,
-  alias: undefined,
-  moduleScopes: undefined,
-  include: [],
-};
-
-const outputDefaults: OutputConfig = {
-  assetPrefix: '/',
-  htmlPath: 'html',
-  jsPath: 'static/js',
-  cssPath: 'static/css',
-  mediaPath: 'static/media',
-  path: 'dist',
-  title: '',
-  titleByEntries: undefined,
-  meta: {
-    charset: { charset: 'utf-8' },
-    viewport:
-      'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
-    'http-equiv': { 'http-equiv': 'x-ua-compatible', content: 'ie=edge' },
-    renderer: 'webkit',
-    layoutmode: 'standard',
-    imagemode: 'force',
-    'wap-font-scale': 'no',
-    'format-detection': 'telephone=no',
-  },
-  metaByEntries: undefined,
-  inject: 'head',
-  injectByEntries: undefined,
-  mountId: 'root',
-  favicon: '',
-  faviconByEntries: undefined,
-  copy: undefined,
-  scriptExt: undefined,
-  disableHtmlFolder: false,
-  disableCssModuleExtension: false,
-  disableCssExtract: false,
-  enableCssModuleTSDeclaration: false,
-  disableMinimize: false,
-  enableInlineStyles: false,
-  enableInlineScripts: false,
-  disableSourceMap: false,
-  disableInlineRuntimeChunk: false,
-  disableAssetsCache: false,
-  enableLatestDecorators: false,
-  polyfill: 'entry',
-  dataUriLimit: 10000,
-  templateParameters: {},
-  templateParametersByEntries: undefined,
-  cssModuleLocalIdentName: '[name]__[local]--[hash:base64:5]',
-  enableModernMode: false,
-  federation: undefined,
-  disableNodePolyfill: false,
-  enableTsLoader: false,
-};
-
-const serverDefaults: ServerConfig = {
-  routes: undefined,
-  publicRoutes: undefined,
-  ssr: undefined,
-  ssrByEntries: undefined,
-  baseUrl: '/',
-  port: 8080,
-};
-
-const devDefaults = { assetPrefix: false, https: false };
-
-const deployDefaults = {
-  domain: '',
-  domainByEntries: undefined,
-};
-
-const toolsDefaults = {
-  webpack: undefined,
-  babel: undefined,
-  postcss: undefined,
-  autoprefixer: undefined,
-  lodash: undefined,
-  devServer: undefined,
-  tsLoader: undefined,
-  terser: undefined,
-  minifyCss: undefined,
-};
-
-export const defaults = {
-  source: sourceDefaults,
-  output: outputDefaults,
-  server: serverDefaults,
-  dev: devDefaults,
-  deploy: deployDefaults,
-  tools: toolsDefaults,
-};