@modern-js/server 1.4.3 → 1.4.4-beta.0

package/tests/middleware.test.ts

@@ -1,179 +0,0 @@
-import path from 'path';
-import EventEmitter from 'events';
-import { Readable } from 'stream';
-import { createServer, Server } from 'http';
-import httpMocks from 'node-mocks-http';
-import portfinder from 'portfinder';
-import axios from 'axios';
-import { createContext } from '../src/libs/context';
-import { createStaticFileHandler } from '../src/libs/serve-file';
-import { createProxyHandler } from '../src/libs/proxy';
-
-describe('test middleware create factory', () => {
-  describe('should create static-file handler correctly', () => {
-    const middleware = createStaticFileHandler([
-      {
-        path: /static\/|upload\//,
-        target: path.join(__dirname, './fixtures/hosting-files'),
-      },
-    ]);
-
-    test('should get static file correctly', resolve => {
-      const req = httpMocks.createRequest({
-        path: '/static/index.js',
-        eventEmitter: Readable,
-      });
-      const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
-      const mockContext = createContext(req, res);
-      res.on('finish', () => {
-        expect(res._getBuffer().toString().trim()).toBe(
-          "console.info('index.js');",
-        );
-        resolve();
-      });
-
-      middleware(mockContext, () => {
-        throw new Error('should not happened');
-      });
-    });
-
-    test('should miss static file correctly', resolve => {
-      const req = httpMocks.createRequest({
-        path: '/static/index.css',
-        eventEmitter: Readable,
-      });
-      const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
-      const mockContext = createContext(req, res);
-      res.on('finish', () => {
-        throw new Error('should not happened');
-      });
-
-      middleware(mockContext, () => {
-        req.destroy();
-        expect(true).toBeTruthy();
-        resolve();
-      });
-    });
-  });
-
-  jest.setTimeout(1000 * 10);
-  describe('should create proxy handler correctly', () => {
-    test('should return null if no options', () => {
-      expect(createProxyHandler(null as any)).toBeNull();
-    });
-
-    let sourceServerPort = 8080;
-    let sourceServer: Server | null = null;
-    beforeAll(async () => {
-      let done: any;
-      const promise = new Promise(resolve => (done = resolve));
-      sourceServerPort = await portfinder.getPortPromise();
-      sourceServer = createServer((req, res) => {
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.write(req.url?.slice(1));
-        res.end();
-      }).listen(sourceServerPort, done);
-      return promise;
-    });
-
-    afterAll(() => {
-      if (sourceServer) {
-        sourceServer.close();
-      }
-    });
-
-    test('should proxy correctly use simply options', async () => {
-      const port = await portfinder.getPortPromise();
-      const middlewares = createProxyHandler({
-        '/simple': `http://localhost:${sourceServerPort}`,
-      });
-      const proxyHandler = middlewares![0];
-
-      const server = createServer((req, res) => {
-        const context = createContext(req, res);
-        proxyHandler(context, () => {
-          throw new Error('should not happened');
-        });
-      }).listen(port);
-
-      try {
-        const { data } = await axios.get(`http://localhost:${port}/simple`);
-        expect(data).toBe('simple');
-      } finally {
-        server.close();
-      }
-    });
-
-    test('should proxy correctly use simply obj options', async () => {
-      const port = await portfinder.getPortPromise();
-      const middlewares = createProxyHandler({
-        '/simple-obj': {
-          target: `http://localhost:${sourceServerPort}`,
-        },
-      });
-      const proxyHandler = middlewares![0];
-
-      const server = createServer((req, res) => {
-        const context = createContext(req, res);
-        proxyHandler(context, () => {
-          throw new Error('should not happened');
-        });
-      }).listen(port);
-
-      try {
-        const { data } = await axios.get(`http://localhost:${port}/simple-obj`);
-        expect(data).toBe('simple-obj');
-      } finally {
-        server.close();
-      }
-    });
-
-    test('should proxy correctly use context options', async () => {
-      const port = await portfinder.getPortPromise();
-      const middlewares = createProxyHandler({
-        context: '/context',
-        target: `http://localhost:${sourceServerPort}`,
-      });
-      const proxyHandler = middlewares![0];
-
-      const server = createServer((req, res) => {
-        const context = createContext(req, res);
-        proxyHandler(context, () => {
-          throw new Error('should not happened');
-        });
-      }).listen(port);
-
-      try {
-        const { data } = await axios.get(`http://localhost:${port}/context`);
-        expect(data).toBe('context');
-      } finally {
-        server.close();
-      }
-    });
-
-    test('should proxy correctly use array options', async () => {
-      const port = await portfinder.getPortPromise();
-      const middlewares = createProxyHandler([
-        {
-          context: '/array',
-          target: `http://localhost:${sourceServerPort}`,
-        },
-      ]);
-      const proxyHandler = middlewares![0];
-
-      const server = createServer((req, res) => {
-        const context = createContext(req, res);
-        proxyHandler(context, () => {
-          throw new Error('should not happened');
-        });
-      }).listen(port);
-
-      try {
-        const { data } = await axios.get(`http://localhost:${port}/array`);
-        expect(data).toBe('array');
-      } finally {
-        server.close();
-      }
-    });
-  });
-});

package/tests/render.test.ts

@@ -1,102 +0,0 @@
-import path from 'path';
-import { render } from '../src/libs/render/ssr';
-import { handleDirectory } from '../src/libs/render/static';
-import { LruReader } from '../src/libs/render/reader';
-
-describe('test render function', () => {
-  test('should return content correctly ', async () => {
-    const renderResult = await render(
-      {
-        params: {},
-        pathname: '/foo',
-        host: 'localhost:8080',
-        query: {},
-        url: 'localhost:8080/foo',
-        cookieMap: {},
-        headers: {},
-      } as any,
-      {
-        urlPath: '/foo',
-        bundle: 'bundle.js',
-        distDir: path.join(__dirname, 'fixtures', 'ssr'),
-        template: 'tpl.html',
-        entryName: 'foo',
-        staticGenerate: false,
-      } as any,
-      {
-        extendSSRContext: () => {
-          // empty
-        },
-      } as any,
-    );
-
-    expect(renderResult.content).toMatch('Modern.js');
-    expect(renderResult.contentType).toMatch('text/html; charset=utf-8');
-  });
-
-  test('should handle directory for .html correctly', async () => {
-    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
-
-    const res1 = await handleDirectory(
-      {
-        path: '/modern/bar',
-      } as any,
-      entryPath,
-      '/modern',
-    );
-
-    expect(res1?.content.toString()).toMatch('bar');
-  });
-
-  test('should handle directory for index.html correctly', async () => {
-    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
-
-    const res1 = await handleDirectory(
-      {
-        path: '/modern/foo',
-      } as any,
-      entryPath,
-      '/modern',
-    );
-
-    expect(res1?.content.toString()).toMatch('foo');
-  });
-
-  test('should handle directory for /index.html correctly', async () => {
-    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
-
-    const res1 = await handleDirectory(
-      {
-        path: '/modern/baz/',
-      } as any,
-      entryPath,
-      '/modern',
-    );
-
-    expect(res1?.content.toString()).toMatch('baz');
-  });
-
-  test('should reader work correctly', async () => {
-    const reader = new LruReader();
-    const dir = path.join(__dirname, 'fixtures', 'reader');
-
-    const nullRes = await reader.read(path.join(dir, 'foo.ts'));
-    expect(nullRes).toBeNull();
-
-    const dirRes = await reader.read(path.join(dir, 'test-dir'));
-    expect(dirRes).toBeNull();
-
-    const res = await reader.read(path.join(dir, 'index.ts'));
-    expect(res).not.toBeNull();
-    expect(res?.content.toString()).toMatch('modern');
-
-    const res1 = await reader.read(path.join(dir, 'index.ts'));
-    expect(res1).not.toBeNull();
-    expect(res1?.content.toString()).toMatch('modern');
-
-    reader.update();
-    const res2 = await reader.read(path.join(dir, 'index.ts'));
-    expect(res2).not.toBeNull();
-    expect(res2?.content.toString()).toMatch('modern');
-  });
-});

package/tests/route.test.ts

@@ -1,77 +0,0 @@
-import { RouteMatchManager, RouteMatcher } from '../src/libs/route';
-import spec from './fixtures/route-spec/index.json';
-import dynamic from './fixtures/route-spec/dynamic.json';
-
-describe('test route', () => {
-  describe('test route matcher', () => {
-    test('should matcher work correctyl with simple spec', () => {
-      const routeSpec = spec.routes[0];
-      const matcher = new RouteMatcher(routeSpec);
-      expect(matcher.spec).toBe(routeSpec);
-      expect(matcher.urlPath).toBe(routeSpec.urlPath);
-      expect(matcher.urlReg).toBeUndefined();
-      expect(matcher.urlMatcher).toBeUndefined();
-
-      const { isSSR, isApi, isSPA, urlPath, entryName, entryPath } =
-        matcher.generate('');
-
-      expect(isSSR).toBeTruthy();
-      expect(isApi).toBeFalsy();
-      expect(isSPA).toBeTruthy();
-      expect(urlPath).toBe(routeSpec.urlPath);
-      expect(entryName).toBe(routeSpec.entryName);
-      expect(entryPath).toBe(routeSpec.entryPath);
-
-      expect(matcher.matchEntry('entry')).toBeTruthy();
-      expect(matcher.matchEntry('home')).toBeFalsy();
-      expect(matcher.matchLength('/entry')).toBe(6);
-      expect(matcher.matchUrlPath('/entry')).toBeTruthy();
-      expect(matcher.matchUrlPath('/home')).toBeFalsy();
-    });
-  });
-
-  describe('test route manager', () => {
-    test('should manager work correctly with simple spec', async () => {
-      const manager = new RouteMatchManager();
-      expect(manager.matchers.length).toBe(0);
-      manager.reset(spec.routes);
-      expect(manager.matchers.length).toBe(3);
-
-      const matchedByEntry = manager.matchEntry('home');
-      expect(matchedByEntry).toBeDefined();
-      expect(matchedByEntry?.generate('').entryName).toBe('home');
-
-      const matchedByUrl = manager.match('/entry');
-      expect(matchedByUrl).toBeDefined();
-      expect(matchedByUrl?.generate('').entryName).toBe('entry');
-
-      const SSRUrlBundles = manager.getBundles();
-      expect(SSRUrlBundles).toEqual(['bundles/entry.js', 'bundles/home.js']);
-
-      manager.reset([]);
-      expect(manager.matchers.length).toBe(0);
-    });
-
-    test('should manager work correctly with dynamic spec', async () => {
-      const manager = new RouteMatchManager();
-      expect(manager.matchers.length).toBe(0);
-      manager.reset(dynamic.routes);
-      expect(manager.matchers.length).toBe(1);
-
-      const matched = manager.match('/entry/001');
-      expect(matched).toBeDefined();
-      const route = matched?.generate('/entry/001');
-      expect(route?.entryName).toBe('entry');
-      expect(route?.params).toEqual({ id: '001' });
-
-      const matchedWithTrail = manager.match('/entry/001/a');
-      expect(matchedWithTrail).toBeDefined();
-      const routeWithTrail = matchedWithTrail?.generate('/entry/001/a');
-      expect(routeWithTrail?.entryName).toBe('entry');
-      expect(routeWithTrail?.params).toEqual({ id: '001' });
-
-      const miss = manager.match('/entry');
-      expect(miss).toBeUndefined();
-    });
-  });
-});

package/tests/utils.test.ts

@@ -1,106 +0,0 @@
-import { compile } from 'path-to-regexp';
-import {
-  noop,
-  mergeExtension,
-  toMessage,
-  createErrorDocument,
-  createMiddlewareCollecter,
-  getStaticReg,
-} from '../src/utils';
-
-describe('test server utils', () => {
-  test('should get nothing from noop', async () => {
-    const rtn = noop();
-    expect(rtn).toBeUndefined();
-  });
-
-  test('should merge extension', () => {
-    const middleware = ['foo', 'baz'];
-    const extension = mergeExtension(middleware);
-    expect(extension.middleware).toEqual(middleware);
-  });
-
-  describe('test some case by toMessage func', () => {
-    test('should get message from error like object', () => {
-      const error = new Error('some error happened');
-      const message = toMessage('error info', error);
-      expect(message).toBe('error info: some error happened');
-    });
-
-    test('should get message from error message', () => {
-      const errorMsg = 'some error happened';
-      const message = toMessage('error info', errorMsg);
-      expect(message).toBe('error info: some error happened');
-    });
-  });
-
-  test('should return document text', () => {
-    const doc = createErrorDocument(302, 'redirect');
-    expect(doc).toMatch('302');
-    expect(doc).toMatch('redirect');
-    expect(doc).toMatch('302: redirect');
-  });
-
-  describe('test middleware collector', () => {
-    test('shoule return web middleware correctly', () => {
-      const { addWebMiddleware, getMiddlewares } = createMiddlewareCollecter();
-
-      const before = getMiddlewares();
-      expect(before.web).toEqual([]);
-
-      const middleware = async () => {
-        // empty
-      };
-      addWebMiddleware(middleware);
-      const after = getMiddlewares();
-      expect(after.web).toEqual([middleware]);
-    });
-
-    test('shoule return api middleware correctly', () => {
-      const { addAPIMiddleware, getMiddlewares } = createMiddlewareCollecter();
-
-      const before = getMiddlewares();
-      expect(before.web).toEqual([]);
-
-      const middleware = async () => {
-        // empty
-      };
-      addAPIMiddleware(middleware);
-      const after = getMiddlewares();
-      expect(after.api).toEqual([middleware]);
-    });
-  });
-
-  test('should return full path', () => {
-    const fn = compile('/home/:id', { encode: encodeURIComponent });
-    expect(fn({ id: 2 })).toBe('/home/2');
-  });
-
-  describe('test create static reg', () => {
-    test('should test static path correctly', () => {
-      const reg = getStaticReg();
-      expect(reg.test('/static')).toBeTruthy();
-      expect(reg.test('/upload')).toBeTruthy();
-    });
-
-    test('should test custom static path correctly', () => {
-      const reg = getStaticReg({
-        cssPath: 'static-css',
-      });
-      expect(reg.test('/static-css')).toBeTruthy();
-    });
-
-    test('should test favicon path correctly', () => {
-      const reg = getStaticReg({
-        favicon: 'index.icon',
-        faviconByEntries: {
-          foo: 'foo.icon',
-          baz: 'baz.icon',
-        },
-      });
-      expect(reg.test('/index.icon')).toBeTruthy();
-      expect(reg.test('/foo.icon')).toBeTruthy();
-      expect(reg.test('/baz.icon')).toBeTruthy();
-    });
-  });
-});