@modern-js/core 1.6.0 → 1.7.1-beta.peer.1

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();
-  });
-});

package/tests/schema.test.ts

@@ -1,107 +0,0 @@
-import { patchSchema, traverseSchema } from '../src/config/schema';
-
-describe('patch schemas', () => {
-  test('should add schema succcessfully', () => {
-    const schema = patchSchema([
-      {
-        target: 'foo',
-        schema: { type: 'string' },
-      },
-      {
-        target: 'deploy.foo',
-        schema: { type: 'number' },
-      },
-    ]);
-
-    expect(schema.properties).toHaveProperty('foo');
-
-    expect(schema.properties.deploy.properties).toHaveProperty('foo');
-  });
-
-  test('should throw error when node is undefined', () => {
-    expect(() => {
-      patchSchema([
-        {
-          target: 'deploy.a.foo',
-          schema: { type: 'string' },
-        },
-      ]);
-    }).toThrowError(/^add schema deploy\.a error$/);
-  });
-
-  test(`should throw error on empty target property`, () => {
-    expect(() => {
-      patchSchema([
-        {
-          target: '',
-          schema: { type: 'object' },
-        },
-      ]);
-    }).toThrowError('should return target property in plugin schema.');
-  });
-
-  test(`support schema array in one schema`, () => {
-    const schema = patchSchema([
-      [
-        {
-          target: 'foo',
-          schema: { type: 'string' },
-        },
-        {
-          target: 'tools.foo',
-          schema: { type: 'number' },
-        },
-      ],
-      {
-        target: 'bar',
-        schema: { type: 'string' },
-      },
-    ]);
-
-    expect(schema.properties).toHaveProperty('foo');
-    expect(schema.properties).toHaveProperty('bar');
-    expect(schema.properties.tools.properties).toHaveProperty('foo');
-  });
-});
-
-describe(`traverse schema`, () => {
-  test(`should return all avaliable keys of current schema`, () => {
-    const schema = {
-      type: 'object',
-      properties: {
-        source: {
-          type: 'object',
-          properties: { alias: { type: ['object', 'function'] } },
-        },
-        a: {
-          type: 'object',
-          properties: {
-            b: {
-              type: 'object',
-              properties: { c: { type: 'object' } },
-            },
-            d: { type: 'string' },
-          },
-        },
-        runtime: {
-          type: 'object',
-          properties: {
-            router: { type: ['object', 'boolean'] },
-            state: { type: ['object', 'boolean'] },
-          },
-        },
-        runtimeByEntries: { patternProperties: { '^$': { type: 'string' } } },
-        dev: { type: ['function', 'string'] },
-      },
-    };
-    expect(traverseSchema(schema as any)).toEqual([
-      'source.alias',
-      'a.b.c',
-      'a.d',
-      'runtime.router',
-      'runtime.state',
-      'runtimeByEntries',
-      'dev',
-    ]);
-  });
-});

package/tests/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "jsx": "preserve",
-    "baseUrl": "./",
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "paths": {}
-  }
-}

package/tests/utils.test.ts

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