@modern-js/core 1.7.0 → 1.8.0

package/tests/fixtures/load-plugin/user-plugins/package.json

@@ -1,3 +0,0 @@
-{
-  "name": "user-plugins"
-}

package/tests/fixtures/load-plugin/user-plugins/test-plugin-a.js

@@ -1 +0,0 @@
-module.exports = { name: 'a' };

package/tests/fixtures/load-plugin/user-plugins/test-plugin-b.js

@@ -1,3 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
-exports.default = { name: 'b' };

package/tests/fixtures/load-plugin/user-plugins/test-plugin-c.js

@@ -1,3 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
-exports.default = name => ({ name });

package/tests/index.test.ts

@@ -1,83 +0,0 @@
-import path from 'path';
-import { cli, mergeOptions } 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'));
-    await cli.init(['dev']);
-    expect(loadEnv).toHaveBeenCalledWith(cwd, undefined);
-    // TODO: add more test cases
-  });
-});
-
-describe('test mergeOptions', () => {
-  it('serverConfigFile must exist', () => {
-    const options = mergeOptions({});
-    expect(options).toHaveProperty('serverConfigFile');
-  });
-
-  it('serverConfigFile can be overwritten', () => {
-    const options = mergeOptions({
-      serverConfigFile: 'test',
-    });
-    expect(options.serverConfigFile).toBe('test');
-  });
-});

package/tests/initWatcher.test.ts

@@ -1,63 +0,0 @@
-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);
-    }
-  });
-
-  xtest('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,173 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { loadEnv } from '../src/loadEnv';
-
-const fixture = path.resolve(__dirname, './fixtures/load-env');
-
-fs.mkdirSync(fixture);
-
-const createFixtures = (
-  dir: string,
-  files: {
-    name: string;
-    content: string;
-  }[],
-) => {
-  fs.mkdirSync(path.join(fixture, dir));
-  for (const { name, content } of files) {
-    fs.writeFileSync(path.join(fixture, dir, name), content, 'utf8');
-  }
-};
-
-describe('load environment variables', () => {
-  const defaultEnv = process.env;
-
-  beforeEach(() => (process.env = { ...defaultEnv }));
-
-  afterAll(() => {
-    process.env = { ...defaultEnv };
-    fs.rmSync(fixture, { force: true, recursive: true });
-  });
-
-  test(`support .env file`, () => {
-    createFixtures('base', [
-      {
-        name: '.env',
-        content: `DB_HOST=localhost
-        DB_USER=root
-        DB_PASS=root
-        `,
-      },
-    ]);
-    loadEnv(path.join(fixture, 'base'));
-
-    expect(process.env.DB_HOST).toBe('localhost');
-
-    expect(process.env.DB_USER).toBe('root');
-
-    expect(process.env.DB_PASS).toBe('root');
-  });
-
-  test(`support "environment" .env file`, () => {
-    createFixtures('environment', [
-      {
-        name: '.env',
-        content: `DB_HOST=localhost
-        DB_USER=root
-        DB_PASS=root
-        `,
-      },
-      {
-        name: '.env.production',
-        content: `DB_HOST=localhost
-        DB_USER=root-local-dev
-        `,
-      },
-    ]);
-
-    process.env.NODE_ENV = 'production';
-
-    loadEnv(path.join(fixture, 'environment'));
-
-    expect(process.env.DB_HOST).toBe('localhost');
-
-    expect(process.env.DB_USER).toBe('root-local-dev');
-
-    expect(process.env.DB_PASS).toBe('root');
-
-    delete process.env.NODE_ENV;
-  });
-
-  test(`should have correct priority`, () => {
-    createFixtures('priority', [
-      {
-        name: '.env',
-        content: `DB_HOST=localhost
-        DB_USER=user
-        DB_PASS=pass
-        `,
-      },
-      {
-        name: '.env.production',
-        content: `DB_USER=user_production
-        DB_PASS=pass_production
-        FOO=foo
-        BAR=bar
-        `,
-      },
-      {
-        name: '.env.local',
-        content: `FOO=foo_local
-        BAR=bar_local
-        `,
-      },
-      {
-        name: '.env.production.local',
-        content: `BAR=bar_production_local`,
-      },
-    ]);
-
-    process.env.NODE_ENV = 'production';
-
-    loadEnv(path.join(fixture, 'priority'));
-
-    expect(process.env.DB_HOST).toBe('localhost');
-
-    expect(process.env.DB_USER).toBe('user_production');
-
-    expect(process.env.DB_PASS).toBe('pass_production');
-
-    expect(process.env.FOO).toBe('foo_local');
-
-    expect(process.env.BAR).toBe('bar_production_local');
-
-    delete process.env.NODE_ENV;
-  });
-
-  test(`get custom .env file by MODERN_ENV`, () => {
-    createFixtures('custom_environment', [
-      {
-        name: '.env',
-        content: `DB_HOST=localhost
-        DB_USER=root
-        DB_PASS=root
-        `,
-      },
-      {
-        name: '.env.staging',
-        content: `DB_HOST=localhost
-        DB_USER=root-local-dev
-        `,
-      },
-    ]);
-
-    loadEnv(path.join(fixture, 'custom_environment'), 'staging');
-
-    expect(process.env.DB_HOST).toBe('localhost');
-
-    expect(process.env.DB_USER).toBe('root-local-dev');
-
-    expect(process.env.DB_PASS).toBe('root');
-
-    delete process.env.MODERN_ENV;
-  });
-
-  test(`support dotenv-expand`, () => {
-    createFixtures('expand', [
-      {
-        name: '.env',
-        content: `DB_HOST=localhost
-        DB_USER=\${DB_HOST}001
-        DB_PASS=root
-        `,
-      },
-    ]);
-    loadEnv(path.join(fixture, 'expand'));
-
-    expect(process.env.DB_HOST).toBe('localhost');
-
-    expect(process.env.DB_USER).toBe('localhost001');
-
-    expect(process.env.DB_PASS).toBe('root');
-  });
-});

package/tests/loadPlugin.test.ts

@@ -1,116 +0,0 @@
-import path from 'path';
-import { CliPlugin } from '../src';
-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,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [
-        { cli: path.join(fixture, './test-plugin-a.js') },
-        { server: './test-plugin-b' },
-      ],
-    });
-
-    expect(plugins).toEqual([
-      {
-        cli: {
-          name: 'a',
-        },
-      },
-      {
-        server: './test-plugin-b',
-        serverPkg: './test-plugin-b',
-      },
-    ]);
-  });
-
-  test('should pass options to Plugin', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [{ cli: ['./test-plugin-c', 'c'] }, ['./test-plugin-c', 'c2']],
-    });
-
-    expect(plugins[0].cli!.name).toEqual('c');
-    expect(plugins[1].cli!.name).toEqual('c2');
-  });
-
-  test('should load user string plugin successfully', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [path.join(fixture, './test-plugin-a.js') as any],
-    });
-
-    expect(plugins).toEqual([
-      {
-        cli: {
-          name: 'a',
-        },
-      },
-    ]);
-  });
-
-  test(`should throw error when plugin not found `, () => {
-    const fixture = path.resolve(__dirname, './fixtures/load-plugin/not-found');
-
-    expect(() => {
-      loadPlugins(fixture, {
-        plugins: [{ cli: './test-plugin-a' }, { cli: './plugin-b' }],
-      });
-    }).toThrowError(/^Can not find plugin /);
-  });
-
-  test(`should load new plugin array correctly`, () => {
-    const appDirectory = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-    const plugin = (): CliPlugin => ({
-      name: 'foo',
-    });
-    const userConfig = { plugins: [plugin()] };
-    const loadedPlugins = loadPlugins(appDirectory, userConfig);
-
-    expect(loadedPlugins[0].cli?.name).toEqual('foo');
-  });
-
-  test(`should load new plugin object correctly`, () => {
-    const appDirectory = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-    const plugin = (): CliPlugin => ({
-      name: 'foo',
-    });
-    const userConfig = { plugins: { cli: [plugin()] } };
-    const loadedPlugins = loadPlugins(appDirectory, userConfig);
-
-    expect(loadedPlugins[0].cli?.name).toEqual('foo');
-  });
-});

package/tests/mergeConfig.test.ts

@@ -1,97 +0,0 @@
-import { mergeConfig } from '../src/config/mergeConfig';
-
-describe('load plugins', () => {
-  test('should replace property deeply', () => {
-    expect(
-      mergeConfig([
-        {
-          source: { disableDefaultEntries: false },
-          output: { polyfill: 'usage' },
-        },
-        {
-          source: { disableDefaultEntries: true },
-          output: { polyfill: 'entry' },
-        },
-      ]),
-    ).toEqual({
-      source: { disableDefaultEntries: true },
-      output: { polyfill: 'entry' },
-    });
-  });
-
-  test(`should set value when property value is not undefined `, () => {
-    expect(
-      mergeConfig([
-        { source: { entries: { app: './App.tsx' } } },
-        { source: { entries: { app2: './src/App2.tsx' } } },
-        { server: { baseUrl: './a' } },
-      ]),
-    ).toEqual({
-      source: {
-        entries: {
-          app: './App.tsx',
-          app2: './src/App2.tsx',
-        },
-      },
-      server: { baseUrl: './a' },
-    });
-  });
-
-  test(`should ignore undefined property`, () => {
-    const config = mergeConfig([
-      { source: { entries: { app: './App.tsx' } } },
-      { source: { entries: undefined } },
-      { tools: { webpack: () => ({}) } },
-      { tools: { webpack: undefined } },
-    ]);
-    expect(config.source).toEqual({
-      entries: {
-        app: './App.tsx',
-      },
-    });
-    expect(Array.isArray(config.tools.webpack)).toBe(true);
-    expect(config.tools.webpack?.length).toBe(1);
-  });
-
-  test(`should merge array value`, () => {
-    expect(
-      mergeConfig([
-        { source: { envVars: ['a', 'b'] } },
-        { source: { globalVars: { A: '1' } } },
-        {
-          source: {
-            disableDefaultEntries: true,
-            envVars: ['c', 'd'],
-            globalVars: { B: '2' },
-          },
-        },
-      ]),
-    ).toEqual({
-      source: {
-        disableDefaultEntries: true,
-        envVars: ['a', 'b', 'c', 'd'],
-        globalVars: {
-          A: '1',
-          B: '2',
-        },
-      },
-    });
-  });
-
-  test(`should merge function and object value`, () => {
-    const config = mergeConfig([
-      { source: { alias: { a: 'b' } } },
-      { source: { alias: () => ({ c: 'd' }) } },
-      { tools: { webpack: () => ({}) } },
-      { tools: { webpack: { name: 'test' } } },
-      { tools: { webpack: () => ({}) } },
-    ]);
-    expect(Array.isArray(config.source.alias)).toBe(true);
-    expect(config?.source?.alias?.length).toBe(2);
-    expect(typeof (config.source.alias as Array<any>)[1]).toBe('function');
-    expect(Array.isArray(config.tools.webpack)).toBe(true);
-    expect(config.tools.webpack?.length).toBe(3);
-    expect(typeof (config.tools.webpack as Array<any>)[0]).toBe('function');
-    expect(typeof (config.tools.webpack as Array<any>)[2]).toBe('function');
-  });
-});

package/tests/pluginAPI.test.ts

@@ -1,19 +0,0 @@
-import { CliPlugin, manager } from '../src';
-
-describe('pluginAPI', () => {
-  it('api.setAppContext', done => {
-    const plugin = (): CliPlugin => ({
-      setup(api) {
-        api.setAppContext({
-          ...api.useAppContext(),
-          packageName: 'foo',
-        });
-
-        expect(api.useAppContext().packageName).toEqual('foo');
-        done();
-      },
-    });
-
-    manager.clone().usePlugin(plugin).init();
-  });
-});

package/tests/repeatKeyWarning.test.ts

@@ -1,68 +0,0 @@
-import { repeatKeyWarning } from '../src/utils/repeatKeyWarning';
-import { UserConfig } from '../src/config';
-
-jest.spyOn(process, 'exit').mockImplementation();
-
-describe('check repeated keys in user config', () => {
-  test(`should exit with error`, () => {
-    expect(() => {
-      repeatKeyWarning(
-        {
-          type: 'object',
-          properties: {
-            a: {
-              type: 'object',
-              properties: {
-                b: {
-                  type: 'object',
-                  properties: { c: { type: ['boolean', 'object'] } },
-                },
-              },
-            },
-          },
-        },
-        { a: { b: { c: true } } } as UserConfig,
-        { a: { b: { c: false } } } as UserConfig,
-      );
-    }).toThrowError(
-      'The same configuration a.b.c exists in modern.config.js and package.json.',
-    );
-  });
-
-  test(`should exit succcessfully`, () => {
-    expect(
-      repeatKeyWarning(
-        {
-          type: 'object',
-          properties: {
-            a: {
-              type: 'object',
-              properties: { b: { type: 'string' } },
-            },
-          },
-          c: {
-            type: 'object',
-            proeperties: {
-              d: {
-                type: 'object',
-                properties: { e: { type: 'string' } },
-              },
-              f: { type: 'string' },
-            },
-          },
-        },
-        {
-          a: { b: 'name' },
-          c: { d: { e: 's' } },
-        } as UserConfig,
-        {
-          a: {},
-          c: {
-            d: {},
-            f: 'ss',
-          },
-        } as UserConfig,
-      ),
-    ).toBeUndefined();
-  });
-});