@mimik/api-helper 3.0.0 → 3.0.2

package/lib/securityHandlers.js

@@ -36,14 +36,7 @@ const SCOPE_INDEX = 0;
 const CLAIMS_INDEX = 1;
 const RESOURCE_INDEX = 0;
 
-const getScopes = (conf, securityType) => {
-  let scopes = [];
-
-  conf.operation.security.forEach((security) => {
-    if (security[securityType]) scopes = scopes.concat(security[securityType]);
-  });
-  return scopes;
-};
+const getScopes = (conf, securityType) => conf.operation.security.flatMap(security => security[securityType] || []);
 
 const getError = (message, statusCode) => {
   const error = new Error(message);
@@ -53,15 +46,8 @@ const getError = (message, statusCode) => {
 };
 
 const checkToken = (authToken) => {
-  let token;
+  const token = jwt.decode(authToken);
 
-  try {
-    token = jwt.decode(authToken);
-  }
-  catch (err) {
-    err.statusCode = UNAUTHORIZED_ERROR;
-    throw err;
-  }
   if (!token) {
     throw getError('invalid token', UNAUTHORIZED_ERROR);
   }
@@ -93,17 +79,17 @@ const checkScopes = (tokenScopes, defScopes, definition) => {
   if (!tokenScopes) {
     throw getError('no scope in authorization token', UNAUTHORIZED_ERROR);
   }
-  let claims = [];
+  const claims = [];
   let onBehalf = false;
 
   if (defScopes && defScopes.length !== EMPTY) {
     const currentScopes = tokenScopes.split(SCOPES_SEPARATOR);
     const intersects = [];
-    let resourceIndex = FIRST;
 
     currentScopes.forEach((currentScope) => {
       const analyzedScope = currentScope.split(SCOPE_CLAIMS_SEPARATOR);
       const analyzedResource = analyzedScope[SCOPE_INDEX].split(RESOURCE_SEPARATOR);
+      let resourceIndex = FIRST;
 
       if (analyzedResource[RESOURCE_INDEX] === ON_BEHALF) {
         onBehalf = true;
@@ -129,7 +115,7 @@ const checkScopes = (tokenScopes, defScopes, definition) => {
           if (claimsIntersects.length !== includedClaims.length) {
             throw getError(`incorrect claims included: ${includedClaims.filter(cla => !claimsIntersects.includes(cla))}`, FORBIDDEN_ERROR);
           }
-          claims = claims.concat(claimsIntersects);
+          claims.push(...claimsIntersects);
         }
         intersects.push(analyzedScope[SCOPE_INDEX]);
       }
@@ -141,13 +127,26 @@ const checkScopes = (tokenScopes, defScopes, definition) => {
   return { onBehalf, claims };
 };
 
+const setParam = (req, request, key, value) => {
+  req[key] = value;
+  request[key] = value;
+};
+
+const setParams = (req, request, params) => {
+  Object.keys(params).forEach(key => setParam(req, request, key, params[key]));
+};
+
+const createMockHandler = params => (con, req) => {
+  setParams(req, con.request, params);
+  return true;
+};
+
 export const securityLib = (config) => {
   const verifyTokenClientCredentials = (authToken) => {
     const { server, generic } = config.security;
     const options = {
       audience: (generic.audience === NO_GENERIC) ? server.audience : generic.audience,
       issuer: server.issuer,
-      // subject: `${config.serverSettings.id}@clients`,
     };
 
     try {
@@ -186,19 +185,24 @@ export const securityLib = (config) => {
     }
   };
 
+  const setClientParams = (req, request, token, scopeResult) => {
+    setParam(req, request, TOKEN_PARAMS.claims, scopeResult.claims);
+    if (scopeResult.onBehalf) setParam(req, request, TOKEN_PARAMS.onBehalf, true);
+    if (token.subType) setParam(req, request, TOKEN_PARAMS.tokenType, token.subType);
+    if (token.sub) setParam(req, request, TOKEN_PARAMS.clientId, token.sub);
+    if (token.cust) setParam(req, request, TOKEN_PARAMS.customer, token.cust);
+  };
+
   const AdminSecurity = {
     regular: (con, req) => {
       const authToken = checkHeaders(req.headers);
       const token = checkToken(authToken);
-      const { request } = con;
 
       if (token.subType !== ADMIN && token.subType !== SUB_ADMIN) {
         throw getError('invalid token: wrong type', FORBIDDEN_ERROR);
       }
       if (token.subType === SUB_ADMIN) {
-        if (!token.cust) {
-          throw getError('invalid token: no customer', FORBIDDEN_ERROR);
-        }
+        if (!token.cust) throw getError('invalid token: no customer', FORBIDDEN_ERROR);
       }
       else if (token.sub !== `${config.security.admin.externalId}${CLIENT}`) {
         throw getError(`jwt subject invalid: ${token.sub}`, FORBIDDEN_ERROR);
@@ -206,42 +210,21 @@ export const securityLib = (config) => {
       verifyTokenClientCredentials(authToken);
       const scopeResult = checkScopes(token.scope, getScopes(con, ADMIN_SECURITY), con.api.definition);
 
-      req[TOKEN_PARAMS.claims] = scopeResult.claims;
-      request[TOKEN_PARAMS.claims] = scopeResult.claims;
-      if (token.subType) {
-        req[TOKEN_PARAMS.tokenType] = token.subType;
-        request[TOKEN_PARAMS.tokenType] = token.subType;
-      }
-      if (token.sub) {
-        req[TOKEN_PARAMS.clientId] = token.sub;
-        request[TOKEN_PARAMS.clientId] = token.sub;
-      }
-      if (token.cust) {
-        req[TOKEN_PARAMS.customer] = token.cust;
-        request[TOKEN_PARAMS.customer] = token.cust;
-      }
-      return true;
-    },
-    mock: (con, req) => {
-      const { request } = con;
-
-      req[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      req[TOKEN_PARAMS.tokenType] = ADMIN;
-      req[TOKEN_PARAMS.clientId] = 'dummyClientId';
-      req[TOKEN_PARAMS.customer] = 'dummyCustomer';
-      request[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      request[TOKEN_PARAMS.tokenType] = ADMIN;
-      request[TOKEN_PARAMS.clientId] = 'dummyClientId';
-      request[TOKEN_PARAMS.customer] = 'dummyCustomer';
+      setClientParams(req, con.request, token, scopeResult);
       return true;
     },
+    mock: createMockHandler({
+      [TOKEN_PARAMS.claims]: ['dummyClaims'],
+      [TOKEN_PARAMS.tokenType]: ADMIN,
+      [TOKEN_PARAMS.clientId]: 'dummyClientId',
+      [TOKEN_PARAMS.customer]: 'dummyCustomer',
+    }),
   };
 
   const SystemSecurity = {
     regular: (con, req) => {
       const authToken = checkHeaders(req.headers);
       const token = checkToken(authToken);
-      const { request } = con;
 
       if (token.subType === ADMIN || token.subType === SUB_ADMIN) {
         throw getError('invalid token: wrong type', FORBIDDEN_ERROR);
@@ -249,112 +232,56 @@ export const securityLib = (config) => {
       verifyTokenClientCredentials(authToken);
       const scopeResult = checkScopes(token.scope, getScopes(con, SYSTEM_SECURITY), con.api.definition);
 
-      if (scopeResult.onBehalf) {
-        req[TOKEN_PARAMS.onBehalf] = true;
-        request[TOKEN_PARAMS.onBehalf] = true;
-      }
-      req[TOKEN_PARAMS.claims] = scopeResult.claims;
-      request[TOKEN_PARAMS.claims] = scopeResult.claims;
-      if (token.subType) {
-        req[TOKEN_PARAMS.tokenType] = token.subType;
-        request[TOKEN_PARAMS.tokenType] = token.subType;
-      }
-      if (token.sub) {
-        req[TOKEN_PARAMS.clientId] = token.sub;
-        request[TOKEN_PARAMS.clientId] = token.sub;
-      }
-      if (token.cust) {
-        req[TOKEN_PARAMS.customer] = token.cust;
-        request[TOKEN_PARAMS.customer] = token.cust;
-      }
-      if (token.type === CLUSTER) {
-        req[TOKEN_PARAMS.cluster] = true;
-        request[TOKEN_PARAMS.cluster] = true;
-      }
-      return true;
-    },
-    mock: (con, req) => {
-      const { request } = con;
-
-      req[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      req[TOKEN_PARAMS.tokenType] = 'dummyServiceType';
-      req[TOKEN_PARAMS.clientId] = 'dummyClientId';
-      req[TOKEN_PARAMS.customer] = 'dummyCustomer';
-      request[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      request[TOKEN_PARAMS.tokenType] = 'dummyServiceType';
-      request[TOKEN_PARAMS.clientId] = 'dummyClientId';
-      request[TOKEN_PARAMS.customer] = 'dummyCustomer';
+      setClientParams(req, con.request, token, scopeResult);
+      if (token.type === CLUSTER) setParam(req, con.request, TOKEN_PARAMS.cluster, true);
       return true;
     },
+    mock: createMockHandler({
+      [TOKEN_PARAMS.claims]: ['dummyClaims'],
+      [TOKEN_PARAMS.tokenType]: 'dummyServiceType',
+      [TOKEN_PARAMS.clientId]: 'dummyClientId',
+      [TOKEN_PARAMS.customer]: 'dummyCustomer',
+    }),
   };
 
   const UserSecurity = {
     regular: (con, req) => {
       const authToken = checkHeaders(req.headers);
       const token = checkToken(authToken);
-      const { request } = con;
 
       verifyTokenImplicit(authToken);
       const scopeResult = checkScopes(token.scope, getScopes(con, USER_SECURITY), con.api.definition);
 
-      if (scopeResult.onBehalf) {
-        req[TOKEN_PARAMS.onBehalf] = true;
-        request[TOKEN_PARAMS.onBehalf] = true;
-      }
-      req[TOKEN_PARAMS.claims] = scopeResult.claims;
-      request[TOKEN_PARAMS.claims] = scopeResult.claims;
-      req[TOKEN_PARAMS.tokenType] = USER;
-      request[TOKEN_PARAMS.tokenType] = USER;
-      if (token.sub) {
-        req[TOKEN_PARAMS.userId] = token.sub;
-        request[TOKEN_PARAMS.userId] = token.sub;
-      }
-      if (token.azp) {
-        req[TOKEN_PARAMS.appId] = token.azp;
-        request[TOKEN_PARAMS.appId] = token.azp;
-      }
+      if (scopeResult.onBehalf) setParam(req, con.request, TOKEN_PARAMS.onBehalf, true);
+      setParam(req, con.request, TOKEN_PARAMS.claims, scopeResult.claims);
+      setParam(req, con.request, TOKEN_PARAMS.tokenType, USER);
+      if (token.sub) setParam(req, con.request, TOKEN_PARAMS.userId, token.sub);
+      if (token.azp) setParam(req, con.request, TOKEN_PARAMS.appId, token.azp);
       if (token.may_act && token.may_act.sub) {
-        req[TOKEN_PARAMS.onBehalfId] = token.sub;
-        request[TOKEN_PARAMS.onBehalfId] = token.sub;
-        req[TOKEN_PARAMS.userId] = token.may_act.sub;
-        request[TOKEN_PARAMS.userId] = token.may_act.sub;
+        setParam(req, con.request, TOKEN_PARAMS.onBehalfId, token.sub);
+        setParam(req, con.request, TOKEN_PARAMS.userId, token.may_act.sub);
       }
       return true;
     },
-    mock: (con, req) => {
-      const { request } = con;
-
-      req[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      req[TOKEN_PARAMS.userId] = 'dummyUserId';
-      req[TOKEN_PARAMS.appId] = 'dummyAppId';
-      req[TOKEN_PARAMS.tokenType] = USER;
-      request[TOKEN_PARAMS.claims] = ['dummyClaims'];
-      request[TOKEN_PARAMS.userId] = 'dummyUserId';
-      request[TOKEN_PARAMS.appId] = 'dummyAppId';
-      request[TOKEN_PARAMS.tokenType] = USER;
-      return true;
-    },
+    mock: createMockHandler({
+      [TOKEN_PARAMS.claims]: ['dummyClaims'],
+      [TOKEN_PARAMS.userId]: 'dummyUserId',
+      [TOKEN_PARAMS.appId]: 'dummyAppId',
+      [TOKEN_PARAMS.tokenType]: USER,
+    }),
   };
 
   const ApiKeySecurity = {
     regular: (con, req) => {
       const apiKey = req.headers ? req.headers[API_KEY_NAME.toLowerCase()] : null;
-      const { request } = con;
 
-      if (config.security.apiKeys.includes(apiKey)) {
-        req[API_KEY_NAME] = apiKey;
-        request[API_KEY_NAME] = apiKey;
+      if (config.security.apiKeys && config.security.apiKeys.includes(apiKey)) {
+        setParam(req, con.request, API_KEY_NAME, apiKey);
         return true;
       }
       throw getError('invalid API key', UNAUTHORIZED_ERROR);
     },
-    mock: (con, req) => {
-      const { request } = con;
-
-      req[API_KEY_NAME] = 'dummyApiKey';
-      request[API_KEY_NAME] = 'dummyApiKey';
-      return true;
-    },
+    mock: createMockHandler({ [API_KEY_NAME]: 'dummyApiKey' }),
   };
 
   return {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@mimik/api-helper",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "helper for openAPI backend and mimik service",
   "main": "./index.js",
   "type": "module",
+  "exports": "./index.js",
   "scripts": {
     "lint": "eslint . --no-error-on-unmatched-pattern",
     "docs": "jsdoc2md index.js > README.md",
-    "test": "mocha test/ --recursive",
+    "test": "mocha --reporter mochawesome --bail --check-leaks --exit test/ --recursive",
     "test-ci": "c8 --reporter=lcov --reporter=text npm test",
     "prepublishOnly": "npm run docs && npm run lint && npm run test-ci",
     "commit-ready": "npm run docs && npm run lint && npm run test-ci"
@@ -27,29 +28,31 @@
     "url": "https://bitbucket.org/mimiktech/api-helper"
   },
   "dependencies": {
-    "@mimik/request-retry": "^4.0.9",
-    "@mimik/response-helper": "^4.0.10",
-    "@mimik/sumologic-winston-logger": "^2.1.14",
-    "@mimik/swagger-helper": "^5.0.3",
+    "@mimik/request-retry": "^4.0.11",
+    "@mimik/response-helper": "^4.0.11",
+    "@mimik/sumologic-winston-logger": "^2.2.2",
+    "@mimik/swagger-helper": "^5.0.4",
     "ajv-formats": "3.0.1",
     "js-base64": "3.7.8",
     "js-yaml": "4.1.1",
     "jsonwebtoken": "9.0.3",
     "openapi-backend": "5.16.1",
-    "swagger-client": "3.36.2"
+    "swagger-client": "3.37.1"
   },
   "devDependencies": {
-    "@eslint/js": "9.32.0",
-    "@mimik/eslint-plugin-document-env": "^2.0.8",
-    "@stylistic/eslint-plugin": "5.9.0",
+    "@eslint/js": "9.39.4",
+    "@mimik/eslint-plugin-document-env": "^2.0.9",
+    "@mimik/eslint-plugin-logger": "^1.0.3",
+    "@stylistic/eslint-plugin": "5.10.0",
     "c8": "11.0.0",
     "chai": "6.2.2",
-    "eslint": "9.32.0",
+    "eslint": "9.39.4",
     "eslint-plugin-import": "2.32.0",
     "esmock": "2.7.3",
-    "globals": "17.3.0",
+    "globals": "17.4.0",
     "husky": "9.1.7",
     "jsdoc-to-markdown": "9.1.3",
-    "mocha": "11.7.5"
+    "mocha": "11.7.5",
+    "mochawesome": "7.1.4"
   }
 }

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx mocha:*)",
-      "Bash(npm test:*)",
-      "Bash(npx eslint:*)"
-    ]
-  }
-}

package/.husky/pre-commit

@@ -1,2 +0,0 @@
-#!/bin/sh
-npm run commit-ready

package/.husky/pre-push

@@ -1,2 +0,0 @@
-#!/bin/sh
-npm run test

package/eslint.config.js

@@ -1,82 +0,0 @@
-import globals from 'globals';
-import importPlugin from 'eslint-plugin-import';
-import js from '@eslint/js';
-import processDoc from '@mimik/eslint-plugin-document-env';
-import stylistic from '@stylistic/eslint-plugin';
-
-const MAX_LENGTH_LINE = 180;
-const MAX_FUNCTION_PARAMETERS = 6;
-const MAX_LINES_IN_FILES = 600;
-const MAX_LINES_IN_FUNCTION = 150;
-const MAX_STATEMENTS_IN_FUNCTION = 45;
-const MIN_KEYS_IN_OBJECT = 10;
-const MAX_COMPLEXITY = 30;
-const ECMA_VERSION = 'latest';
-const MAX_DEPTH = 6;
-const ALLOWED_CONSTANTS = [0, 1, -1];
-
-export default [
-  {
-    ignores: ['mochawesome-report/**', 'node_modules/**', 'dist/**'],
-  },
-  importPlugin.flatConfigs.recommended,
-  stylistic.configs.recommended,
-  js.configs.all,
-  {
-    plugins: {
-      processDoc,
-    },
-    languageOptions: {
-      ecmaVersion: ECMA_VERSION,
-      globals: {
-        ...globals.mocha,
-        ...globals.nodeBuiltin,
-      },
-      sourceType: 'module',
-    },
-    rules: {
-      '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
-      '@stylistic/line-comment-position': ['off'],
-      '@stylistic/max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true, ignoreStrings: true, ignoreRegExpLiterals: true }],
-      '@stylistic/quotes': ['warn', 'single'],
-      '@stylistic/semi': ['error', 'always'],
-      'capitalized-comments': ['off'],
-      'complexity': ['error', MAX_COMPLEXITY],
-      'curly': ['off'],
-      'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
-      'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
-      'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
-      'init-declarations': ['off'],
-      'linebreak-style': ['off'],
-      'max-depth': ['error', MAX_DEPTH],
-      'max-len': ['off'],
-      'max-lines': ['warn', { max: MAX_LINES_IN_FILES, skipComments: true, skipBlankLines: true }],
-      'max-lines-per-function': ['warn', { max: MAX_LINES_IN_FUNCTION, skipComments: true, skipBlankLines: true }],
-      'max-params': ['error', MAX_FUNCTION_PARAMETERS],
-      'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
-      'no-confusing-arrow': ['off'],
-      'no-inline-comments': ['off'],
-      'no-magic-numbers': ['error', { ignore: ALLOWED_CONSTANTS, enforceConst: true, detectObjects: true }],
-      'no-process-env': ['error'],
-      'no-ternary': ['off'],
-      'no-undefined': ['off'],
-      'one-var': ['error', 'never'],
-      'processDoc/validate-document-env': ['error'],
-      'quotes': ['off'],
-      'sort-imports': ['error', { allowSeparatedGroups: true }],
-      'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false, allowLineSeparatedGroups: true }],
-    },
-  },
-  {
-    files: ['test/**/*.js'],
-    rules: {
-      'class-methods-use-this': ['off'],
-      'max-classes-per-file': ['off'],
-      'max-lines': ['off'],
-      'max-lines-per-function': ['off'],
-      'max-statements': ['off'],
-      'no-empty-function': ['off'],
-      'no-magic-numbers': ['off'],
-    },
-  },
-];

package/test/ajvHelpers.test.js

@@ -1,159 +0,0 @@
-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);
-    });
-  });
-});