@mimik/api-helper 2.0.7 → 2.0.8

package/test/baseHandlers.test.js

@@ -0,0 +1,150 @@
+import { ERROR_CODE } from '@mimik/response-helper';
+import esmock from 'esmock';
+import { expect } from 'chai';
+
+let baseHandlers;
+let lastRejectArgs;
+
+describe('baseHandlers', () => {
+  before(async () => {
+    const mod = await esmock('../lib/baseHandlers.js', {
+      '@mimik/swagger-helper': {
+        rejectRequest: (error, con, res) => {
+          lastRejectArgs = { error, con, res };
+        },
+      },
+    });
+
+    baseHandlers = mod.default;
+  });
+
+  beforeEach(() => {
+    lastRejectArgs = null;
+  });
+
+  describe('validationFail', () => {
+    it('should create error with status 400 and call rejectRequest', () => {
+      const con = { validation: { errors: [{ message: 'bad field' }], warnings: ['warn1'] } };
+      const req = { method: 'POST', url: '/test' };
+      const res = {};
+
+      baseHandlers.validationFail(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('Failed schema validation');
+      expect(lastRejectArgs.error.statusCode).to.equal(ERROR_CODE.PARAMETER);
+      expect(lastRejectArgs.error.info).to.deep.equal({
+        method: 'POST',
+        path: '/test',
+        errors: [{ message: 'bad field' }],
+        warnings: ['warn1'],
+      });
+      expect(lastRejectArgs.con).to.equal(con);
+      expect(lastRejectArgs.res).to.equal(res);
+    });
+
+    it('should default warnings to empty array when not present', () => {
+      const con = { validation: { errors: [] } };
+      const req = { method: 'GET', url: '/path' };
+      const res = {};
+
+      baseHandlers.validationFail(con, req, res);
+      expect(lastRejectArgs.error.info.warnings).to.deep.equal([]);
+    });
+  });
+
+  describe('notFound', () => {
+    it('should create error with status 404 and the path', () => {
+      const con = {};
+      const req = { method: 'GET', url: '/unknown' };
+      const res = {};
+
+      baseHandlers.notFound(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('path /unknown not defined in Swagger specification');
+      expect(lastRejectArgs.error.statusCode).to.equal(ERROR_CODE.NOT_FOUND);
+      expect(lastRejectArgs.error.info).to.deep.equal({ method: 'GET', path: '/unknown' });
+    });
+  });
+
+  describe('unauthorizedHandler', () => {
+    it('should use default Unauthorized error when no scheme error exists', () => {
+      const con = { security: { authorized: true, SystemSecurity: {} } };
+      const req = {};
+      const res = {};
+
+      baseHandlers.unauthorizedHandler(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('Unauthorized');
+      expect(lastRejectArgs.error.statusCode).to.equal(ERROR_CODE.UNAUTHORIZED);
+    });
+
+    it('should use scheme error when present', () => {
+      const schemeError = new Error('token expired');
+
+      schemeError.statusCode = ERROR_CODE.FORBIDDEN;
+      const con = { security: { authorized: false, SystemSecurity: { error: schemeError } } };
+      const req = {};
+      const res = {};
+
+      baseHandlers.unauthorizedHandler(con, req, res);
+      expect(lastRejectArgs.error).to.equal(schemeError);
+      expect(lastRejectArgs.error.message).to.equal('token expired');
+    });
+
+    it('should filter out the authorized key from security schemes', () => {
+      const schemeError = new Error('forbidden');
+      const con = { security: { authorized: true, AdminSecurity: { error: schemeError } } };
+      const req = {};
+      const res = {};
+
+      baseHandlers.unauthorizedHandler(con, req, res);
+      expect(lastRejectArgs.error).to.equal(schemeError);
+    });
+
+    it('should handle scheme with no error property', () => {
+      const con = { security: { authorized: false, SystemSecurity: null } };
+      const req = {};
+      const res = {};
+
+      baseHandlers.unauthorizedHandler(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('Unauthorized');
+    });
+  });
+
+  describe('notImplemented', () => {
+    it('should create error with status 501 and include operationId', () => {
+      const con = { operation: { operationId: 'getUsers' } };
+      const req = { method: 'GET', url: '/users' };
+      const res = {};
+
+      baseHandlers.notImplemented(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('GET /users defined in Swagger specification, but not implemented');
+      expect(lastRejectArgs.error.statusCode).to.equal(ERROR_CODE.NOT_IMPLEMENTED);
+      expect(lastRejectArgs.error.info).to.deep.equal({
+        method: 'GET',
+        path: '/users',
+        operationId: 'getUsers',
+      });
+    });
+  });
+
+  describe('methodNotAllowed', () => {
+    it('should create error with status 501 for disallowed method', () => {
+      const con = {};
+      const req = { method: 'DELETE', url: '/items' };
+      const res = {};
+
+      baseHandlers.methodNotAllowed(con, req, res);
+      expect(lastRejectArgs.error.message).to.equal('path /items defined in Swagger specification, but the method DELETE is not defined');
+      expect(lastRejectArgs.error.statusCode).to.equal(ERROR_CODE.NOT_IMPLEMENTED);
+      expect(lastRejectArgs.error.info).to.deep.equal({ method: 'DELETE', path: '/items' });
+    });
+  });
+
+  describe('exports', () => {
+    it('should export all five handlers', () => {
+      expect(baseHandlers).to.have.property('validationFail').that.is.a('function');
+      expect(baseHandlers).to.have.property('notFound').that.is.a('function');
+      expect(baseHandlers).to.have.property('unauthorizedHandler').that.is.a('function');
+      expect(baseHandlers).to.have.property('notImplemented').that.is.a('function');
+      expect(baseHandlers).to.have.property('methodNotAllowed').that.is.a('function');
+    });
+  });
+});

package/test/extract-helper.test.js

@@ -0,0 +1,100 @@
+import esmock from 'esmock';
+import { expect } from 'chai';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const getRichError = (type, message, info, cause) => {
+  const error = new Error(message);
+
+  error.type = type;
+  error.info = info;
+  if (cause) error.cause = cause;
+  return error;
+};
+
+const logEntries = [];
+const mockLogger = {
+  info: (msg, ...args) => logEntries.push({ level: 'info', msg, args }),
+  debug: (msg, ...args) => logEntries.push({ level: 'debug', msg, args }),
+  warn: (msg, ...args) => logEntries.push({ level: 'warn', msg, args }),
+  error: (msg, ...args) => logEntries.push({ level: 'error', msg, args }),
+};
+
+let saveProperties;
+let tmpDir;
+
+describe('extract-helper', () => {
+  before(async () => {
+    const mod = await esmock('../lib/extract-helper.js', {
+      '@mimik/response-helper': { getRichError },
+      '@mimik/sumologic-winston-logger': mockLogger,
+    });
+
+    ({ saveProperties } = mod);
+  });
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'extract-helper-test-'));
+    logEntries.length = 0;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create the build directory if it does not exist', () => {
+    const buildDir = path.join(tmpDir, 'build');
+
+    saveProperties({}, buildDir, 'controllers', 'corr-1');
+    expect(fs.existsSync(buildDir)).to.equal(true);
+  });
+
+  it('should create register.js with correct imports and exports', () => {
+    const extractResult = {
+      userController: ['getUser', 'createUser'],
+      adminController: ['getAdmin'],
+    };
+
+    saveProperties(extractResult, tmpDir, 'controllers', 'corr-2');
+    const registerFile = path.join(tmpDir, 'register.js');
+
+    expect(fs.existsSync(registerFile)).to.equal(true);
+    const content = fs.readFileSync(registerFile, 'utf8');
+
+    expect(content).to.include('import {\n  getUser,\n  createUser,\n} from \'../controllers/userController.js\';');
+    expect(content).to.include('import {\n  getAdmin,\n} from \'../controllers/adminController.js\';');
+    expect(content).to.include('export {\n  getUser,\n  createUser,\n  getAdmin,\n};');
+  });
+
+  it('should include eslint disable comment at the top', () => {
+    saveProperties({}, tmpDir, 'controllers', 'corr-3');
+    const content = fs.readFileSync(path.join(tmpDir, 'register.js'), 'utf8');
+
+    expect(content).to.match(/^\/\* eslint sort-imports:"off" \*\//u);
+  });
+
+  it('should remove existing register.js before writing', () => {
+    const registerFile = path.join(tmpDir, 'register.js');
+
+    fs.writeFileSync(registerFile, 'old content');
+    saveProperties({ ctrl: ['op1'] }, tmpDir, 'controllers', 'corr-4');
+    const content = fs.readFileSync(registerFile, 'utf8');
+
+    expect(content).to.not.include('old content');
+    expect(content).to.include('op1');
+  });
+
+  it('should handle empty extractResult', () => {
+    saveProperties({}, tmpDir, 'controllers', 'corr-5');
+    const content = fs.readFileSync(path.join(tmpDir, 'register.js'), 'utf8');
+
+    expect(content).to.include('export {\n};');
+  });
+
+  it('should throw when build directory cannot be created', () => {
+    const badPath = '/nonexistent/deeply/nested/path';
+
+    expect(() => saveProperties({}, badPath, 'controllers', 'corr-6')).to.throw('file system error');
+  });
+});