code coverage

Author: cblanquera

ingest/package.json

@@ -189,16 +189,13 @@
     "build:tsc": "yarn build:tsc:cjs && yarn build:tsc:esm",
     "build:tsc:cjs": "tsc -p ./tsconfig.cjs.json",
     "build:tsc:esm": "tsc -p ./tsconfig.esm.json",
-    "test": "yarn test:env nyc ts-mocha -r tsx tests/*.test.ts",
-    "test:env": "NODE_OPTIONS=\"--disable-warning=ExperimentalWarning --experimental-loader @istanbuljs/esm-loader-hook\"",
-    "report": "nyc report -r lcov"
+    "test": "ts-mocha -r tsx tests/*.test.ts"
   },
   "dependencies": {
     "@stackpress/lib": "0.10.3",
     "@whatwg-node/server": "0.10.17"
   },
   "devDependencies": {
-    "@istanbuljs/esm-loader-hook": "0.3.0",
     "@types/chai": "4.3.20",
     "@types/mocha": "10.0.10",
     "@types/node": "25.3.5",

ingest/tests/Decorator.test.ts

@@ -7,7 +7,32 @@ import Server from '../src/Server.js';
 import Request from '../src/Request.js';
 import Response from '../src/Response.js';
 import type { ActionRouteProps } from '../src/types.js';
-import { Controller, Get, On, Post, mount } from '../src/decorators.js';
+import {
+  All,
+  Connect,
+  Controller,
+  Delete,
+  Get,
+  Head,
+  On,
+  Options,
+  Patch,
+  Post,
+  Put,
+  Trace,
+  addEvent,
+  addRoute,
+  assertHandler,
+  controllerOf,
+  hasEvent,
+  hasRoute,
+  metadataOf,
+  mount,
+  normalizePath,
+  registerEvent,
+  registerRoute,
+  routeDecorator
+} from '../src/decorators.js';
 
 type TestRouterProps = ActionRouteProps<
   unknown,
@@ -127,4 +152,220 @@ describe('Decorator Tests', () => {
     await server.emit('GET /api/users', req, res);
     expect(res.headers.get('x-hook')).to.equal('true');
   });
+
+  it('Should expose decorator helper utilities for direct mounting flows',
+    async () => {
+      class UtilityController {
+        public prefix = 'utility';
+
+        public route({ res }: TestRouterProps) {
+          res.set('text/plain', this.prefix);
+        }
+
+        public event({ res }: TestRouterProps) {
+          res.headers.set('x-utility', 'true');
+        }
+      }
+
+      const metadata = metadataOf(UtilityController);
+      addRoute(UtilityController, {
+        method: 'GET',
+        path: '/utility//path',
+        property: 'route',
+        priority: 4
+      });
+      addRoute(UtilityController, {
+        method: 'GET',
+        path: '/utility//path',
+        property: 'route',
+        priority: 4
+      });
+      addEvent(UtilityController, {
+        event: 'GET /api/utility/path',
+        property: 'event',
+        priority: 6
+      });
+      addEvent(UtilityController, {
+        event: 'GET /api/utility/path',
+        property: 'event',
+        priority: 6
+      });
+
+      const controller = controllerOf(UtilityController);
+      const router = new Router();
+
+      registerRoute(router, controller, '/api/', metadata.routes[0]);
+      registerEvent(router, controller, metadata.events[0]);
+
+      const req = new Request({
+        method: 'GET',
+        url: new URL('http://localhost/api/utility/path')
+      });
+      const res = new Response();
+      await router.emit('GET /api/utility/path', req, res);
+
+      expect(hasRoute(metadata, metadata.routes[0])).to.equal(true);
+      expect(hasEvent(metadata, metadata.events[0])).to.equal(true);
+      expect(normalizePath('/api/', '/utility//path')).to.equal(
+        '/api/utility/path'
+      );
+      expect(res.body).to.equal('utility');
+      expect(res.headers.get('x-utility')).to.equal('true');
+    });
+
+  it('Should reject non-function controller members when mounting', () => {
+    const controller = { broken: 'nope' };
+
+    expect(() => assertHandler(controller, 'broken')).to.throw(
+      'Controller member "broken" is not a function'
+    );
+  });
+
+  it('Should cover the remaining http method decorators', async () => {
+    @Controller('/extra')
+    class ExtraController {
+      @All('/all')
+      public all({ res }: TestRouterProps) {
+        res.set('text/plain', 'all');
+      }
+
+      @Connect('/connect')
+      public connect({ res }: TestRouterProps) {
+        res.set('text/plain', 'connect');
+      }
+
+      @Delete('/delete')
+      public remove({ res }: TestRouterProps) {
+        res.set('text/plain', 'delete');
+      }
+
+      @Head('/head')
+      public head({ res }: TestRouterProps) {
+        res.set('text/plain', 'head');
+      }
+
+      @Options('/options')
+      public options({ res }: TestRouterProps) {
+        res.set('text/plain', 'options');
+      }
+
+      @Patch('/patch')
+      public patch({ res }: TestRouterProps) {
+        res.set('text/plain', 'patch');
+      }
+
+      @Put('/put')
+      public put({ res }: TestRouterProps) {
+        res.set('text/plain', 'put');
+      }
+
+      @Trace('/trace')
+      public trace({ res }: TestRouterProps) {
+        res.set('text/plain', 'trace');
+      }
+    }
+
+    const router = new Router();
+    mount(router, ExtraController);
+
+    const expectations: Array<[ string, string, string ]> = [
+      [ 'POST', '/extra/all', 'all' ],
+      [ 'CONNECT', '/extra/connect', 'connect' ],
+      [ 'DELETE', '/extra/delete', 'delete' ],
+      [ 'HEAD', '/extra/head', 'head' ],
+      [ 'OPTIONS', '/extra/options', 'options' ],
+      [ 'PATCH', '/extra/patch', 'patch' ],
+      [ 'PUT', '/extra/put', 'put' ],
+      [ 'TRACE', '/extra/trace', 'trace' ]
+    ];
+
+    for (const [ method, pathname, body ] of expectations) {
+      const req = new Request({
+        method: method as 'POST',
+        url: new URL(`http://localhost${pathname}`)
+      });
+      const res = new Response();
+      await router.emit(`${method} ${pathname}`, req, res);
+      expect(res.body).to.equal(body);
+    }
+  });
+
+  it('Should support the standard decorator initializer path directly', () => {
+    class StandardController {
+      public handler() {
+        return 'ok';
+      }
+    }
+
+    let routeInitializer: ((this: StandardController) => void)|undefined;
+    let eventInitializer: ((this: StandardController) => void)|undefined;
+
+    routeDecorator('GET')('/standard', 3)(
+      StandardController.prototype.handler,
+      {
+        addInitializer(callback) {
+          routeInitializer = callback as (this: StandardController) => void;
+        },
+        kind: 'method',
+        name: 'handler',
+        static: false
+      } as ClassMethodDecoratorContext
+    );
+
+    On('GET /standard', 5)(
+      StandardController.prototype.handler,
+      {
+        addInitializer(callback) {
+          eventInitializer = callback as (this: StandardController) => void;
+        },
+        kind: 'method',
+        name: 'handler',
+        static: false
+      } as ClassMethodDecoratorContext
+    );
+
+    const controller = new StandardController();
+    routeInitializer?.call(controller);
+    eventInitializer?.call(controller);
+
+    const metadata = metadataOf(StandardController);
+
+    expect(metadata.routes).to.deep.equal([ {
+      method: 'GET',
+      path: '/standard',
+      property: 'handler',
+      priority: 3
+    } ]);
+    expect(metadata.events).to.deep.equal([ {
+      event: 'GET /standard',
+      property: 'handler',
+      priority: 5
+    } ]);
+  });
+
+  it('Should reject static standard decorator targets', () => {
+    expect(() => routeDecorator('GET')('/bad')(
+      () => void 0,
+      {
+        addInitializer() {
+          return void 0;
+        },
+        kind: 'method',
+        name: 'bad',
+        static: true
+      } as ClassMethodDecoratorContext
+    )).to.throw('Decorator "bad" must be an instance method');
+
+    expect(() => On('bad')(
+      () => void 0,
+      {
+        addInitializer() {
+          return void 0;
+        },
+        kind: 'method',
+        name: 'bad',
+        static: true
+      } as ClassMethodDecoratorContext
+    )).to.throw('Decorator "bad" must be an instance method');
+  });
 });