@modern-js/server 1.2.0 → 1.2.1-rc.0

package/tests/route.test.ts

@@ -0,0 +1,54 @@
+import { RouteMatchManager, RouteMatcher } from '../src/libs/route';
+import spec from './fixtures/route-spec/index.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);
+    });
+  });
+});

package/tests/server.test.ts

@@ -0,0 +1,89 @@
+import path from 'path';
+import { defaultsConfig, NormalizedConfig } from '@modern-js/core';
+import { ModernServerContext, NextFunction } from '@modern-js/types';
+import createServer, { Server } from '../src';
+
+describe('test server', () => {
+  test('should throw error when ', resolve => {
+    try {
+      createServer(null as any);
+    } catch (e: any) {
+      expect((e as Error).message).toBe(
+        'can not start mserver without options',
+      );
+      resolve();
+    }
+  });
+
+  test('shoule get modern server instance', async () => {
+    const server = await createServer({
+      config: defaultsConfig as NormalizedConfig,
+      pwd: path.join(__dirname, './fixtures/pure'),
+    });
+    expect(server instanceof Server).toBe(true);
+  });
+
+  describe('shoule get production modern server instance', () => {
+    const appDirectory = path.join(__dirname, './fixtures/pure');
+
+    test('should init server correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+      });
+      const modernServer = (server as any).server;
+
+      const {
+        pwd,
+        distDir,
+        workDir,
+        conf,
+        handlers,
+        isDev,
+        staticGenerate,
+        presetRoutes,
+      } = modernServer;
+      expect(pwd).toBe(appDirectory);
+      expect(distDir).toBe(path.join(appDirectory, 'dist'));
+      expect(workDir).toBe(distDir);
+      expect(conf).toBe(defaultsConfig);
+      expect(handlers).toBeDefined();
+      expect(isDev).toBeFalsy();
+      expect(staticGenerate).toBeFalsy();
+      expect(presetRoutes).toBeUndefined();
+    });
+
+    test('should add handler correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+      });
+      const modernServer = server.server as any;
+
+      const len = modernServer.handlers.length;
+
+      const syncHandler = (ctx: ModernServerContext, next: NextFunction) => {
+        console.info(ctx.url);
+        next();
+      };
+      modernServer.addHandler(syncHandler);
+
+      const newLen = modernServer.handlers.length;
+      expect(len + 1).toBe(newLen);
+      expect(modernServer.handlers[newLen - 1]).not.toBe(syncHandler);
+
+      const asyncHandler = async (
+        ctx: ModernServerContext,
+        next: NextFunction,
+      ) => {
+        console.info(ctx.url);
+        next();
+      };
+      modernServer.addHandler(asyncHandler);
+      const nextLen = modernServer.handlers.length;
+
+      expect(newLen + 1).toBe(nextLen);
+      expect(modernServer.handlers[nextLen - 1]).toBe(asyncHandler);
+    });
+  });
+});

package/tests/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "isolatedModules": true,
+    "sourceMap": true
+  },
+  "paths": {
+    "@/*": ["../src/*"]
+  },
+  "exclude": ["src/__test__/fixtures/**"]
+}

package/tests/utils.test.ts

@@ -0,0 +1,40 @@
+import {
+  noop,
+  mergeExtension,
+  toMessage,
+  createErrorDocument,
+} 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');
+  });
+});