@modern-js/server 1.4.4 → 1.4.7-canary.0

package/tests/fixtures/mock/module-error/config/mock/index.ts

@@ -0,0 +1 @@
+export default null;

package/tests/fixtures/mock/type-error/config/mock/index.ts

@@ -0,0 +1,3 @@
+export default {
+  'GET /api/getInfo': 'foo',
+};

package/tests/fixtures/pure/config/mock/index.ts

@@ -0,0 +1,11 @@
+export default {
+  'GET /api/getInfo': { data: [1, 2, 3, 4] },
+
+  '/api/getExample': { id: 1 },
+
+  'GET /api/addInfo': (req: any, res: any) => {
+    setTimeout(() => {
+      res.end('delay 2000ms');
+    }, 2000);
+  },
+};

package/tests/helper.ts

@@ -0,0 +1,3 @@
+export const noop = () => {
+  // empty
+};

package/tests/https.test.ts

@@ -0,0 +1,17 @@
+import { genHttpsOptions } from '../src/dev-tools/https';
+
+describe('test dev tools', () => {
+  test('should get http cert correctly', async () => {
+    // Todo Interaction in CI
+    // const options = await genHttpsOptions(true);
+    // expect(options.key).toBeDefined();
+    // expect(options.cert).toBeDefined();
+
+    const useOpt = await genHttpsOptions({
+      key: 'foo',
+      cert: 'baz',
+    });
+    expect(useOpt.key).toBe('foo');
+    expect(useOpt.cert).toBe('baz');
+  });
+});

package/tests/launch-editor.test.ts

@@ -0,0 +1,58 @@
+import { LAUNCH_EDITOR_ENDPOINT } from '@modern-js/utils';
+import { createLaunchEditorHandler } from '../src/dev-tools/launch-editor';
+import { noop } from './helper';
+
+describe('should createLaunchEditorHandler work correctly', () => {
+  const middleware = createLaunchEditorHandler();
+
+  it('should return 200 if filename exist', () => {
+    let response: any;
+    const context: any = {
+      url: LAUNCH_EDITOR_ENDPOINT,
+      query: {
+        filename: 'test.ts',
+      },
+      res: {
+        end: (data: any) => {
+          response = data;
+        },
+      },
+    };
+    middleware(context, noop);
+    expect(context.status).toBe(200);
+    expect(response).toBeUndefined();
+  });
+
+  it('should return 500 if filename not exist', () => {
+    let response: any;
+    const context: any = {
+      url: LAUNCH_EDITOR_ENDPOINT,
+      query: {
+        filename: '',
+      },
+      res: {
+        end: (data: any) => {
+          response = data;
+        },
+      },
+    };
+    middleware(context, noop);
+    expect(context.status).toBe(500);
+    expect(typeof response === 'string').toBeTruthy();
+  });
+
+  it('should invoke next if not launch editor url', () => {
+    let response: any;
+    const context: any = {
+      url: '',
+      res: {
+        end: (data: any) => {
+          response = data;
+        },
+      },
+    };
+    middleware(context, noop);
+    expect(context.status).toBeUndefined();
+    expect(response).toBeUndefined();
+  });
+});

package/tests/mock.test.ts

@@ -0,0 +1,150 @@
+import path from 'path';
+import { createMockHandler } from '../src/dev-tools/mock';
+import getMockData, { getMatched } from '../src/dev-tools/mock/getMockData';
+import { noop } from './helper';
+
+describe('test dev tools', () => {
+  describe('should mock middleware work correctly', () => {
+    const pwd = path.join(__dirname, './fixtures/mock');
+
+    it('should return null if no config mock dir', () => {
+      expect(createMockHandler({ pwd: path.join(pwd, 'empty') })).toBeNull();
+    });
+
+    it('should return null if no api dir', () => {
+      expect(createMockHandler({ pwd: path.join(pwd, 'zero') })).toBeNull();
+    });
+
+    it('should return middleware if mock api exist', async () => {
+      const middleware = createMockHandler({ pwd: path.join(pwd, 'exist') });
+
+      expect(middleware).not.toBeNull();
+
+      let response: any;
+      const context: any = {
+        path: '/api/getInfo',
+        method: 'get',
+        res: {
+          setHeader: noop,
+          end: (data: any) => {
+            response = JSON.parse(data);
+          },
+        },
+      };
+      await middleware?.(context, noop);
+      expect(response).toEqual({
+        data: [1, 2, 3, 4],
+      });
+    });
+
+    it('should not return middleware if mock api exist', async () => {
+      const middleware = createMockHandler({ pwd: path.join(pwd, 'exist') });
+
+      expect(middleware).not.toBeNull();
+
+      let response: any;
+      const context: any = {
+        path: '/api/getInfp',
+        method: 'get',
+        res: {
+          setHeader: noop,
+          end: (data: any) => {
+            response = JSON.parse(data);
+          },
+        },
+      };
+      await middleware?.(context, noop);
+      expect(response).toBeUndefined();
+    });
+
+    it('should get api list correctly', resolve => {
+      const apiList = getMockData(path.join(pwd, 'exist/config/mock/index.ts'));
+      expect(apiList.length).toBe(3);
+
+      const pathList = apiList.map(api => api.path);
+      expect(pathList).toEqual([
+        '/api/getInfo',
+        '/api/getExample',
+        '/api/addInfo',
+      ]);
+
+      let response: any;
+      const context: any = {
+        res: {
+          setHeader: noop,
+          end: (data: any) => {
+            try {
+              response = JSON.parse(data);
+            } catch (e) {
+              response = data;
+            }
+          },
+        },
+      };
+
+      apiList[0].handler(context, noop as any);
+      expect(response).toEqual({
+        data: [1, 2, 3, 4],
+      });
+      apiList[1].handler(context, noop as any);
+      expect(response).toEqual({ id: 1 });
+
+      apiList[2].handler(context, noop as any);
+      setTimeout(() => {
+        expect(response).toBe('delay 2000ms');
+        resolve();
+      }, 3000);
+    });
+
+    it('should match api correctly', () => {
+      const apiList = [
+        {
+          method: 'get',
+          path: '/api/getInfo',
+          handler: noop,
+        },
+        {
+          method: 'get',
+          path: '/api/getExample',
+          handler: noop,
+        },
+        {
+          method: 'get',
+          path: '/api/addInfo',
+          handler: noop,
+        },
+      ];
+      const matched = getMatched(
+        { path: '/api/getInfo', method: 'get' } as any,
+        apiList,
+      );
+      expect(matched).toBe(apiList[0]);
+
+      const missMethod = getMatched(
+        { path: '/api/getModern', method: 'post' } as any,
+        apiList,
+      );
+      expect(missMethod).toBeUndefined();
+    });
+
+    it('should throw error if get mock file fail', resolve => {
+      try {
+        createMockHandler({ pwd: path.join(pwd, 'module-error') });
+      } catch (e: any) {
+        expect(e.message).toMatch('parsed failed!');
+        resolve();
+      }
+    });
+
+    it('should throw error if get mock api has wrong type', resolve => {
+      try {
+        createMockHandler({ pwd: path.join(pwd, 'type-error') });
+      } catch (e: any) {
+        expect(e.message).toMatch(
+          'should be object or function, but got string',
+        );
+        resolve();
+      }
+    });
+  });
+});

package/tests/server.test.ts

@@ -1,10 +1,16 @@
 import path from 'path';
 import { defaultsConfig, NormalizedConfig } from '@modern-js/core';
 import { ModernServerContext, NextFunction } from '@modern-js/types';
+import { webpack } from 'webpack';
+import { AGGRED_DIR, RUN_MODE } from '@modern-js/prod-server';
 import createServer, { Server } from '../src';
 import Watcher from '../src/dev-tools/watcher';
+import { ModernDevServer } from '../src/server/dev-server';
 
-describe('test server', () => {
+jest.useFakeTimers();
+(global as any).setImmediate = () => false;
+const appDirectory = path.join(__dirname, './fixtures/pure');
+describe('test dev server', () => {
   test('should throw error when ', resolve => {
     try {
       createServer(null as any);
@@ -18,17 +24,24 @@ describe('test server', () => {
 
   test('shoule get modern server instance', async () => {
     const server = await createServer({
-      config: defaultsConfig as NormalizedConfig,
-      pwd: path.join(__dirname, './fixtures/pure'),
+      config: {
+        ...defaultsConfig,
+        tools: {
+          devServer: {
+            proxy: {
+              '/simple': `http://localhost:8080`,
+            },
+          },
+        },
+      } as any,
+      pwd: appDirectory,
       dev: true,
     });
     expect(server instanceof Server).toBe(true);
     await server.close();
   });
 
-  describe('shoule get production modern server instance', () => {
-    const appDirectory = path.join(__dirname, './fixtures/pure');
-
+  describe('shoule get dev modern server instance', () => {
     test('should init server correctly', async () => {
       const server = await createServer({
         config: defaultsConfig as NormalizedConfig,
@@ -105,23 +118,121 @@ describe('test server', () => {
       expect(typeof handler === 'function').toBeTruthy();
       await server.close();
     });
-  });
-});
 
-describe('dev server', () => {
-  const pwd = path.join(__dirname, './fixtures/pure');
-  let devServer: Server;
+    test('should get request handler correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+      });
 
-  test('watch', async () => {
-    devServer = await createServer({
-      config: defaultsConfig as NormalizedConfig,
-      pwd,
-      dev: true,
+      const modernServer: any = (server as any).server;
+      const handler = modernServer.getRequestHandler();
+      expect(typeof handler === 'function').toBeTruthy();
+      await server.close();
+    });
+
+    test('should invoke onrepack correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+      });
+
+      const modernServer: ModernDevServer = (server as any).server;
+      modernServer.onRepack({ routes: [] });
+
+      expect((modernServer as any).router.matchers.length).toBe(0);
+      server.close();
+    });
+
+    test('should invoke onserver change correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+      });
+
+      const modernServer = (server as any).server;
+      modernServer.onServerChange({
+        filepath: path.join(appDirectory, AGGRED_DIR.mock),
+      });
+      expect(modernServer.mockHandler).not.toBeNull();
+
+      modernServer.onServerChange({
+        filepath: path.join(appDirectory, 'index.js'),
+      });
+      expect(modernServer.mockHandler).not.toBeNull();
+      server.close();
+    });
+
+    test('should compiler work correctly', async () => {
+      const compiler = webpack({});
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+        compiler,
+      });
+
+      expect(server).toBeDefined();
+      server.close();
+    });
+
+    test('should multi compiler work correctly', async () => {
+      const compiler = webpack([{}, { name: 'client' }]);
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+        compiler,
+      });
+
+      expect(server).toBeDefined();
+      server.close();
+    });
+
+    test('should watcher work well', async () => {
+      const devServer = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+      });
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      expect(devServer.server.watcher).toBeInstanceOf(Watcher);
+      await devServer.close();
     });
+  });
 
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-expect-error
-    expect(devServer.server.watcher).toBeInstanceOf(Watcher);
-    await devServer.close();
+  describe('should split server work correctly', () => {
+    test('should init api server correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+        apiOnly: true,
+        runMode: RUN_MODE.FULL,
+      });
+      const modernServer = (server as any).server;
+      modernServer.emitRouteHook('reset', {});
+      expect(modernServer.prepareWebHandler()).toBe(null);
+      await server.close();
+    });
+
+    test('should init ssr server correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+        dev: true,
+        ssrOnly: true,
+        runMode: RUN_MODE.FULL,
+      });
+      const modernServer = (server as any).server;
+      modernServer.emitRouteHook('reset', {});
+      expect(modernServer.prepareAPIHandler()).toBe(null);
+      await server.close();
+    });
   });
 });

package/tests/watcher.test.ts

@@ -1,40 +1,70 @@
-import * as path from 'path';
+import path from 'path';
 import { fs } from '@modern-js/utils';
-import Watcher from '../src/dev-tools/watcher';
+import Watcher, { getWatchedFiles } from '../src/dev-tools/watcher';
+import { StatsCache } from '../src/dev-tools/watcher/stats-cache';
 
 jest.useRealTimers();
 
 describe('watcher', () => {
-  let watcher: Watcher;
   jest.setTimeout(25000);
+  const pwd = path.join(__dirname, './fixtures/watch');
+  const serverDir = path.normalize(path.join(pwd, './tmp-server'));
+
   beforeAll(() => {
-    watcher = new Watcher();
+    if (fs.existsSync(serverDir)) {
+      fs.removeSync(serverDir);
+    }
+    fs.mkdirSync(serverDir);
   });
 
-  test('should emit change', done => {
-    const pwd = path.join(__dirname, './fixtures/pure');
-    const serverDir = path.normalize(path.join(pwd, './tmp-server'));
+  afterAll(() => {
+    fs.removeSync(serverDir);
+  });
 
+  const writeFiles = (content: string, filepath: string) => {
+    fs.writeFileSync(path.normalize(filepath), content, 'utf8');
+  };
+
+  test('should emit add', done => {
+    const watcher = new Watcher();
     const callback = jest.fn();
-    if (fs.pathExistsSync(serverDir)) {
-      fs.removeSync(serverDir);
-    }
-    const writeFiles = () => {
-      fs.writeFileSync(
-        path.normalize(path.join(serverDir, 'index.js')),
-        'test',
-        'utf8',
-      );
-    };
 
-    const clear = () => {
-      fs.removeSync(serverDir);
-    };
+    const watchDir = path.join(serverDir, 'add');
+    fs.mkdirSync(watchDir);
 
-    fs.mkdirSync(serverDir);
+    watcher.listen(
+      [`${watchDir}/**/*`],
+      {
+        ignoreInitial: true,
+        ignored: /api\/typings\/.*/,
+      },
+      async () => {
+        try {
+          callback();
+          expect(callback).toHaveBeenCalledTimes(1);
+          await watcher.close();
+        } catch (e) {
+          console.error(e);
+        }
+        done();
+      },
+    );
+
+    setTimeout(() => writeFiles('test', path.join(watchDir, 'index.js')), 100);
+  });
+
+  test('should emit unlink', done => {
+    const watcher = new Watcher();
+
+    const callback = jest.fn();
+    const watchDir = path.join(serverDir, 'unlink');
+    fs.mkdirSync(watchDir);
+
+    const filepath = path.join(watchDir, 'index.js');
+    writeFiles('unlink', filepath);
 
     watcher.listen(
-      [`${serverDir}/**/*`],
+      [`${watchDir}/**/*`],
       {
         ignoreInitial: true,
         ignored: /api\/typings\/.*/,
@@ -43,16 +73,44 @@ describe('watcher', () => {
         callback();
         expect(callback).toHaveBeenCalledTimes(1);
         await watcher.close();
-        clear();
         done();
       },
     );
 
-    setTimeout(writeFiles, 100);
+    setTimeout(() => {
+      fs.removeSync(filepath);
+    }, 100);
+  });
+
+  test('should emit change', done => {
+    const watcher = new Watcher();
+
+    const callback = jest.fn();
+    const watchDir = path.join(serverDir, 'change');
+    fs.mkdirSync(watchDir);
+
+    const filepath = path.join(watchDir, 'index.js');
+    writeFiles('start', filepath);
+
+    watcher.listen(
+      [`${watchDir}/**/*`],
+      {
+        ignoreInitial: true,
+        ignored: /api\/typings\/.*/,
+      },
+      async () => {
+        callback();
+        expect(callback).toHaveBeenCalledTimes(1);
+        await watcher.close();
+        done();
+      },
+    );
+
+    setTimeout(() => writeFiles('end', filepath), 100);
   });
 
   test('should not emit change when typings file changed', done => {
-    const pwd = path.join(__dirname, './fixtures/pure');
+    const watcher = new Watcher();
     const apiDir = path.normalize(path.join(pwd, './api'));
 
     const callback = jest.fn();
@@ -61,14 +119,6 @@ describe('watcher', () => {
       fs.removeSync(apiDir);
     }
 
-    const writeFiles = () => {
-      fs.writeFileSync(
-        path.normalize(path.join(apiDir, 'typings/index.js')),
-        'test',
-        'utf8',
-      );
-    };
-
     const clear = () => {
       fs.removeSync(apiDir);
     };
@@ -92,7 +142,87 @@ describe('watcher', () => {
       clear();
       done();
     }, 1000);
+  });
+});
+
+describe('test watcher', () => {
+  let watcher: any;
+  const baseDir = path.join(__dirname, 'fixtures');
+  const watchDir = path.join(baseDir, 'watch/**');
+  const filepath = path.join(baseDir, 'watch', 'index.ts');
+  const filepatha = path.join(baseDir, 'watch', 'a.ts');
+  const txt = path.join(baseDir, 'watch', 'stats.txt');
+
+  afterEach(() => {
+    if (watcher) {
+      watcher.close();
+    }
+    fs.writeFileSync(txt, '1');
+  });
+
+  it('should create watcher instance correctly', resolve => {
+    watcher = new Watcher();
+    expect(watcher.dependencyTree).toBeNull();
+    watcher.createDepTree();
+    expect(watcher.dependencyTree).not.toBeNull();
+
+    expect(watcher.watcher).toBeUndefined();
+    watcher.listen([watchDir], {}, () => {
+      // empty
+    });
+
+    expect(watcher.watcher).toBeDefined();
+    require(filepath);
+    expect(watcher.dependencyTree.getNode(filepath)).toBeUndefined();
+    watcher.updateDepTree();
+    expect(watcher.dependencyTree.getNode(filepath)).toBeDefined();
+    watcher.cleanDepCache(filepath);
+    expect(watcher.dependencyTree.getNode(filepath)).toBeDefined();
+
+    jest.resetModules();
+    watcher.updateDepTree();
+    expect(watcher.dependencyTree.getNode(filepath)).toBeUndefined();
+
+    setTimeout(() => {
+      const fl = getWatchedFiles(watcher.watcher);
+      expect(fl.includes(filepatha)).toBeTruthy();
+      expect(fl.includes(filepath)).toBeTruthy();
+      expect(fl.includes(txt)).toBeTruthy();
+      resolve();
+    }, 1000);
+  });
+
+  it('should stats cache instance work correctly', () => {
+    const statsCache = new StatsCache();
+
+    // should not exist false before add
+    expect(statsCache.has(txt)).toBeFalsy();
+
+    // should exist true after add
+    statsCache.add([txt]);
+    expect(statsCache.has(txt)).toBeTruthy();
+
+    // should diff correctly
+    fs.writeFileSync(txt, 'foo');
+    expect(statsCache.isDiff(txt)).toBeTruthy();
+
+    // should not diff if not refresh
+    fs.writeFileSync(txt, '1');
+    expect(statsCache.isDiff(txt)).toBeFalsy();
+
+    // should diff after refresh
+    fs.writeFileSync(txt, 'foo');
+    statsCache.refresh(txt);
+    fs.writeFileSync(txt, '1');
+    expect(statsCache.isDiff(txt)).toBeTruthy();
+
+    // should diff when content change
+    statsCache.refresh(txt);
+    fs.writeFileSync(txt, '2');
+    expect(statsCache.isDiff(txt)).toBeTruthy();
 
-    setTimeout(writeFiles);
+    // should not exist after del
+    statsCache.del(txt);
+    expect(statsCache.has(txt)).toBeFalsy();
   });
 });