@mimik/api-helper 2.0.6 → 2.0.8

package/test/ajvHelpers.test.js

@@ -0,0 +1,159 @@
+import esmock from 'esmock';
+import { expect } from 'chai';
+
+let ajvFormats;
+let addedLibFormats;
+let addedCustomFormats;
+
+describe('ajvHelpers', () => {
+  before(async () => {
+    const mod = await esmock('../lib/ajvHelpers.js', {
+      'ajv-formats': {
+        default: (ajv, formats) => {
+          addedLibFormats = formats;
+        },
+      },
+    });
+
+    ({ ajvFormats } = mod);
+  });
+
+  beforeEach(() => {
+    addedLibFormats = null;
+    addedCustomFormats = {};
+  });
+
+  const createMockAjv = () => ({
+    addFormat: (name, format) => {
+      addedCustomFormats[name] = format;
+    },
+  });
+
+  describe('with no extra formats', () => {
+    it('should add default library formats', () => {
+      const ajv = createMockAjv();
+      const configurer = ajvFormats();
+
+      configurer(ajv);
+      expect(addedLibFormats).to.deep.equal(['date', 'time', 'date-time', 'byte', 'uuid', 'uri', 'email', 'ipv4', 'ipv6']);
+    });
+
+    it('should add built-in semver and ip custom formats', () => {
+      const ajv = createMockAjv();
+      const configurer = ajvFormats();
+
+      configurer(ajv);
+      expect(addedCustomFormats).to.have.property('semver');
+      expect(addedCustomFormats.semver.type).to.equal('string');
+      expect(addedCustomFormats).to.have.property('ip');
+      expect(addedCustomFormats.ip.type).to.equal('string');
+    });
+
+    it('should return the ajv instance', () => {
+      const ajv = createMockAjv();
+      const configurer = ajvFormats();
+      const result = configurer(ajv);
+
+      expect(result).to.equal(ajv);
+    });
+  });
+
+  describe('with null extra formats', () => {
+    it('should treat null as no extra formats', () => {
+      const ajv = createMockAjv();
+      const configurer = ajvFormats(null);
+
+      configurer(ajv);
+      expect(addedLibFormats).to.deep.equal(['date', 'time', 'date-time', 'byte', 'uuid', 'uri', 'email', 'ipv4', 'ipv6']);
+    });
+  });
+
+  describe('with extra library formats (string-only)', () => {
+    it('should append format names to the library formats list', () => {
+      const ajv = createMockAjv();
+      const configurer = ajvFormats({ hostname: {} });
+
+      configurer(ajv);
+      expect(addedLibFormats).to.include('hostname');
+      expect(addedLibFormats).to.have.lengthOf(10);
+    });
+  });
+
+  describe('with extra custom formats (with type)', () => {
+    it('should add custom format via ajv.addFormat', () => {
+      const customFormat = { type: 'string', validate: /^[A-Z]+$/u };
+      const ajv = createMockAjv();
+      const configurer = ajvFormats({ uppercase: customFormat });
+
+      configurer(ajv);
+      expect(addedCustomFormats).to.have.property('uppercase');
+      expect(addedCustomFormats.uppercase).to.equal(customFormat);
+      expect(addedLibFormats).to.not.include('uppercase');
+    });
+  });
+
+  describe('semver validation', () => {
+    it('should accept valid semver strings', () => {
+      const ajv = createMockAjv();
+
+      ajvFormats()(ajv);
+      const { validate } = addedCustomFormats.semver;
+
+      expect(validate.test('1.0.0')).to.equal(true);
+      expect(validate.test('0.1.0')).to.equal(true);
+      expect(validate.test('1.2.3-alpha.1')).to.equal(true);
+      expect(validate.test('1.2.3+build.123')).to.equal(true);
+      expect(validate.test('1.2.3-beta+build')).to.equal(true);
+    });
+
+    it('should reject invalid semver strings', () => {
+      const ajv = createMockAjv();
+
+      ajvFormats()(ajv);
+      const { validate } = addedCustomFormats.semver;
+
+      expect(validate.test('1.0')).to.equal(false);
+      expect(validate.test('abc')).to.equal(false);
+      expect(validate.test('1.0.0.0')).to.equal(false);
+    });
+  });
+
+  describe('ip validation', () => {
+    it('should accept valid IPv4 addresses', () => {
+      const ajv = createMockAjv();
+
+      ajvFormats()(ajv);
+      const { validate } = addedCustomFormats.ip;
+
+      expect(validate.test('192.168.1.1')).to.equal(true);
+      expect(validate.test('10.0.0.1')).to.equal(true);
+      expect(validate.test('255.255.255.255')).to.equal(true);
+    });
+
+    it('should accept valid IPv6 addresses', () => {
+      const ajv = createMockAjv();
+
+      ajvFormats()(ajv);
+      const { validate } = addedCustomFormats.ip;
+
+      expect(validate.test('::1')).to.equal(true);
+      expect(validate.test('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).to.equal(true);
+    });
+  });
+
+  describe('DEFAULT_FORMATS isolation', () => {
+    it('should not mutate DEFAULT_FORMATS between calls', () => {
+      const ajv1 = createMockAjv();
+      const ajv2 = createMockAjv();
+
+      ajvFormats({ extra1: {} })(ajv1);
+      const firstCallLength = addedLibFormats.length;
+
+      ajvFormats()(ajv2);
+      const secondCallLength = addedLibFormats.length;
+
+      expect(secondCallLength).to.equal(9);
+      expect(firstCallLength).to.equal(10);
+    });
+  });
+});

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');
+  });
+});