@mimik/configuration 6.0.8 → 6.0.9

package/README.md

@@ -84,7 +84,7 @@ The following environment variables are being used for the configuration:
 | OAUTH_GENERIC_PREVIOUS_KEY | key for the token signature before change the public key | | security.generic.previousKey | [2]
 | OAUTH_GENERIC_AUDIENCE | url representing the generic of the service type to mST | noGeneric | security.generic.audience | [2]
 | API_KEYS | list of API Keys which are tested against in case of APIKey security | [] |
-| LOG_MODE | collector to be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, 'awsKinesis'
+| LOG_MODE | collector to be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, `awsKinesis`, `none`
 | NO_STACK | disable the inclusion of the stack in all logs | yes | logInfo.noStack
 | FILTER_FILE | path for the filter file definition | null | logInfo.filterFile |
 | USER_DEFINITIONS_FILE | path for the custom user definitions | null | userDefinitions.file |
@@ -100,7 +100,7 @@ The following environment variables are being used for the configuration:
 | MIT_AUDIENCE | audience of mIT |  | dependencies.mIT.audience | [2]
 | REGISTRATION_SET | switch to enable use of registration | on | registration.set | can be `on` or `off`
 | REGISTRATION_RETRY | retry time for registering to mIT | 3000 | registration.retry | in milliseconds
-| REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration of execution the postOps | off | registration.afterPostOpsSet | can be `on` or `off`
+| REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration after the execution of the postOps | off | registration.afterPostOpsSet | can be `on` or `off`
 | `$_URL`.toUpperCase() | cluster information | self | dependencies.`(SERVER_TYPE)`.url | should not be used
 | `${configuration.serverSettings.type}_AUDIENCE`.toUpperCase() | cluster information |  | dependencies.`(SERVER_TYPE)`.audience | [2], but should not be used
 

package/index.js

@@ -496,7 +496,7 @@ configuration.locationProvider = setupLocationProvider();
  * | OAUTH_GENERIC_PREVIOUS_KEY | key for the token signature before change the public key | | security.generic.previousKey | [2]
  * | OAUTH_GENERIC_AUDIENCE | url representing the generic of the service type to mST | noGeneric | security.generic.audience | [2]
  * | API_KEYS | list of API Keys which are tested against in case of APIKey security | [] |
- * | LOG_MODE | collector to be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, 'awsKinesis'
+ * | LOG_MODE | collector to be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, `awsKinesis`, `none`
  * | NO_STACK | disable the inclusion of the stack in all logs | yes | logInfo.noStack
  * | FILTER_FILE | path for the filter file definition | null | logInfo.filterFile |
  * | USER_DEFINITIONS_FILE | path for the custom user definitions | null | userDefinitions.file |
@@ -512,7 +512,7 @@ configuration.locationProvider = setupLocationProvider();
  * | MIT_AUDIENCE | audience of mIT |  | dependencies.mIT.audience | [2]
  * | REGISTRATION_SET | switch to enable use of registration | on | registration.set | can be `on` or `off`
  * | REGISTRATION_RETRY | retry time for registering to mIT | 3000 | registration.retry | in milliseconds
- * | REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration of execution the postOps | off | registration.afterPostOpsSet | can be `on` or `off`
+ * | REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration after the execution of the postOps | off | registration.afterPostOpsSet | can be `on` or `off`
  * | `${configuration.serverSettings.type}_URL`.toUpperCase() | cluster information | self | dependencies.`(SERVER_TYPE)`.url | should not be used
  * | `${configuration.serverSettings.type}_AUDIENCE`.toUpperCase() | cluster information |  | dependencies.`(SERVER_TYPE)`.audience | [2], but should not be used
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimik/configuration",
-  "version": "6.0.8",
+  "version": "6.0.9",
   "description": "Common configuration for mimik services",
   "main": "./index.js",
   "exports": "./index.js",

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,87 +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.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'],
-    languageOptions: {
-      globals: {
-        ...globals.mocha,
-      },
-    },
-    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'],
-      'processDoc/validate-document-env': ['off'],
-    },
-  },
-];

package/manual-test/test-config.js

@@ -1,48 +0,0 @@
-/* eslint-disable no-console */
-import './testEnv.js';
-import { setConfig } from '../index.js';
-// import Config from '../index.js';
-
-const pack = {
-  swaggerFile: {
-    version: '2.0.6',
-    account: 'mimiktech',
-    name: 'swagger-mds',
-  },
-  mimik: {
-    type: 'test-pack-type',
-  },
-};
-const config = {
-  database: {
-    type: 'mongodb',
-    table: {
-      itResource: 'itResource',
-      lease: 'lease',
-    },
-  },
-  dependencies: {
-    'mIT': {
-      audience: 'test-audience',
-      url: 'test-url',
-    },
-    'test-pack-type': {
-      audience: 'test-pack-type-audience',
-    },
-  },
-  security: {
-    server: {
-      id: 'test-security-id',
-      secret: 'test-security-secret',
-      accessKey: 'test-security-access-key',
-      audience: 'test-security-audience',
-      issuer: 'test-security-issuer',
-    },
-  },
-  serverSettings: {
-    type: 'test-type',
-  },
-};
-
-const configuration = setConfig(pack, config);
-console.log(configuration);

package/manual-test/testEnv.js

@@ -1,21 +0,0 @@
-/* eslint no-process-env: "off" */
-import process from 'process';
-
-/**
- *
- * Test configuration Configuration.
- *
- * @description The following environment variables are needed to configure configuration:
- *
- * | Env variable name | Description | Default | Comments |
- * | ----------------- | ----------- | ------- | -------- |
- * | DATABASE_NAME | name of the database to use for mongodb
- * | MONGO_REPLICAT_SET | set to a value for Boolean()
- * | SUMO_LOGIC_ENDPOINT | dummy endpoint for sumologic
- * | SUMO_LOGIC_COLLECTOR_CODE | dummy collector code for sumologic
- */
-
-process.env.DATABASE_NAME = 'test-database-name';
-process.env.MONGO_REPLICAT_SET = 'test-mongo-replicat-set';
-process.env.SUMO_LOGIC_ENDPOINT = 'test-logInfo-sumologic-endpoint';
-process.env.SUMO_LOGIC_COLLECTOR_CODE = 'test-logInfo-sumologic-code';

package/test/configuration.spec.js

@@ -1,1038 +0,0 @@
-/* eslint no-process-env: "off" */
-import './testEnv.js';
-
-import {
-  after,
-  afterEach,
-  before,
-  describe,
-  it,
-} from 'mocha';
-import esmock from 'esmock';
-import { expect } from 'chai';
-import process from 'node:process';
-import { stub } from 'sinon';
-
-// Minimal valid pack object for setConfig
-const basePack = {
-  name: '@mimik/test-service',
-  version: '1.0.0',
-  mimik: { type: 'mTest' },
-  swaggerFile: {
-    version: '1.0.0',
-    account: 'mimiktech',
-    name: 'test-api',
-  },
-};
-
-// Minimal valid options for setConfig
-const baseOptions = {};
-
-// Mock stubs for dependencies
-const mockLogger = {
-  error: stub(),
-  warn: stub(),
-  info: stub(),
-  debug: stub(),
-  verbose: stub(),
-  flushAndExit: stub(),
-  flush: stub(),
-};
-
-const mockGetCorrelationId = stub().returns('mock-correlation-id@0/2026-01-01T00:00:00.000Z');
-const mockIpAddress = stub().returns('127.0.0.1');
-const mockUserDefinitions = {
-  all: { attributes: ['nickname'], properties: ['nickName'] },
-  basic: { attributes: ['nickname'], properties: ['nickName'] },
-};
-
-// Helper to import module with esmock and optional env overrides
-const importModule = async (envOverrides = {}) => {
-  const savedEnv = {};
-  for (const [key, value] of Object.entries(envOverrides)) {
-    savedEnv[key] = process.env[key];
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = value;
-  }
-
-  const mod = await esmock('../index.js', {
-    '@mimik/sumologic-winston-logger': { default: mockLogger },
-    '@mimik/request-helper': { getCorrelationId: mockGetCorrelationId },
-    '@mimik/user-filters': { userDefinitions: mockUserDefinitions },
-    'ip': { address: mockIpAddress },
-  });
-
-  return { mod, savedEnv };
-};
-
-const restoreEnv = (savedEnv) => {
-  for (const [key, value] of Object.entries(savedEnv)) {
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = value;
-  }
-};
-
-const resetStubs = () => {
-  mockLogger.error.reset();
-  mockLogger.warn.reset();
-  mockLogger.info.reset();
-  mockLogger.debug.reset();
-  mockLogger.verbose.reset();
-  mockLogger.flush.reset();
-  mockLogger.flushAndExit.reset();
-};
-
-// ============================================================
-// Tests
-// ============================================================
-
-describe('configuration Unit Tests', () => {
-  // ----------------------------------------------------------
-  // isProd
-  // ----------------------------------------------------------
-  describe('isProd()', () => {
-    let isProd;
-    let savedEnv;
-
-    before(async () => {
-      const result = await importModule();
-      ({ isProd } = result.mod);
-      ({ savedEnv } = result);
-    });
-    after(() => restoreEnv(savedEnv));
-    afterEach(() => {
-      delete process.env.NODE_ENV;
-    });
-
-    it('should return true when NODE_ENV is "prod"', () => {
-      process.env.NODE_ENV = 'prod';
-      expect(isProd()).to.equal(true);
-    });
-
-    it('should return true when NODE_ENV is "production"', () => {
-      process.env.NODE_ENV = 'production';
-      expect(isProd()).to.equal(true);
-    });
-
-    it('should return true when NODE_ENV is "PROD" (case insensitive)', () => {
-      process.env.NODE_ENV = 'PROD';
-      expect(isProd()).to.equal(true);
-    });
-
-    it('should return true when NODE_ENV is "Production" (case insensitive)', () => {
-      process.env.NODE_ENV = 'Production';
-      expect(isProd()).to.equal(true);
-    });
-
-    it('should return false when NODE_ENV is "local"', () => {
-      process.env.NODE_ENV = 'local';
-      expect(isProd()).to.equal(false);
-    });
-
-    it('should return false when NODE_ENV is "development"', () => {
-      process.env.NODE_ENV = 'development';
-      expect(isProd()).to.equal(false);
-    });
-
-    it('should return false when NODE_ENV is undefined', () => {
-      delete process.env.NODE_ENV;
-      expect(isProd()).to.equal(false);
-    });
-
-    it('should return false when NODE_ENV is empty string', () => {
-      process.env.NODE_ENV = '';
-      expect(isProd()).to.equal(false);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // Module-level side effects
-  // ----------------------------------------------------------
-  describe('Module-level side effects', () => {
-    it('should set SERVER_LOCAL_IPV4 to the mocked IP address', async () => {
-      const { savedEnv } = await importModule();
-      expect(process.env.SERVER_LOCAL_IPV4).to.equal('127.0.0.1');
-      restoreEnv(savedEnv);
-    });
-
-    it('should set AWS_LOCAL_PROPERTIES to 169.254.169.254', async () => {
-      const { savedEnv } = await importModule();
-      expect(process.env.AWS_LOCAL_PROPERTIES).to.equal('169.254.169.254');
-      restoreEnv(savedEnv);
-    });
-
-    it('should set CONSOLE_LEVEL to debug if not already set', async () => {
-      const saved = process.env.CONSOLE_LEVEL;
-      delete process.env.CONSOLE_LEVEL;
-      const { savedEnv } = await importModule();
-      expect(process.env.CONSOLE_LEVEL).to.equal('debug');
-      restoreEnv(savedEnv);
-      process.env.CONSOLE_LEVEL = saved;
-    });
-
-    it('should preserve existing CONSOLE_LEVEL if already set', async () => {
-      process.env.CONSOLE_LEVEL = 'warn';
-      const { savedEnv } = await importModule();
-      expect(process.env.CONSOLE_LEVEL).to.equal('warn');
-      restoreEnv(savedEnv);
-      process.env.CONSOLE_LEVEL = 'debug';
-    });
-
-    it('should set SERVER_ID if not already set', async () => {
-      const saved = process.env.SERVER_ID;
-      delete process.env.SERVER_ID;
-      await importModule();
-      expect(process.env.SERVER_ID).to.be.a('string');
-      expect(process.env.SERVER_ID.length).to.be.greaterThan(0);
-      if (saved) process.env.SERVER_ID = saved;
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - base configuration
-  // ----------------------------------------------------------
-  describe('setConfig(pack, options) - base', () => {
-    let setConfig;
-    let savedEnv;
-
-    before(async () => {
-      const result = await importModule();
-      ({ setConfig } = result.mod);
-      ({ savedEnv } = result);
-      resetStubs();
-    });
-    after(() => restoreEnv(savedEnv));
-    afterEach(() => resetStubs());
-
-    it('should set SERVER_VERSION, SERVER_NAME, SERVER_TYPE from pack', () => {
-      setConfig(basePack, baseOptions);
-      expect(process.env.SERVER_VERSION).to.equal('1.0.0');
-      expect(process.env.SERVER_NAME).to.equal('@mimik/test-service');
-      expect(process.env.SERVER_TYPE).to.equal('mTest');
-    });
-
-    it('should return a configuration object with serverSettings populated', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.serverSettings.name).to.equal('@mimik/test-service');
-      expect(config.serverSettings.type).to.equal('mTest');
-      expect(config.serverSettings.version).to.equal('1.0.0');
-    });
-
-    it('should default swagger provider to bitbucket when not provided', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(process.env.SWAGGER_FILE_PROVIDER).to.equal('bitbucket');
-      expect(config.serverSettings.swaggerFile.provider).to.equal('bitbucket');
-    });
-
-    it('should set swagger file properties from pack', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.serverSettings.swaggerFile.version).to.equal('1.0.0');
-      expect(config.serverSettings.swaggerFile.account).to.equal('mimiktech');
-      expect(config.serverSettings.swaggerFile.name).to.equal('test-api');
-    });
-
-    it('should use provided swagger provider when specified', () => {
-      const packWithProvider = {
-        ...basePack,
-        swaggerFile: { ...basePack.swaggerFile, provider: 'swaggerhub' },
-      };
-      const config = setConfig(packWithProvider, baseOptions);
-      expect(config.serverSettings.swaggerFile.provider).to.equal('swaggerhub');
-    });
-
-    it('should throw for unsupported swagger provider', () => {
-      const packBadProvider = {
-        ...basePack,
-        swaggerFile: { ...basePack.swaggerFile, provider: 'gitlab' },
-      };
-      expect(() => setConfig(packBadProvider, baseOptions))
-        .to.throw('swaggerFile provider not supported: gitlab');
-    });
-
-    it('should construct the api path correctly', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.serverSettings.api).to.equal('../api/mimiktech_test-api_1.0.0_swagger.json');
-    });
-
-    it('should use SWAGGER_FILE_DIRECTORY env var for api path', () => {
-      process.env.SWAGGER_FILE_DIRECTORY = '/custom/api';
-      const config = setConfig(basePack, baseOptions);
-      expect(config.serverSettings.api).to.include('/custom/api/');
-      delete process.env.SWAGGER_FILE_DIRECTORY;
-    });
-
-    it('should return default config values', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.cache.set).to.equal('off');
-      expect(config.topic.set).to.equal('off');
-      expect(config.encryption.set).to.equal('off');
-      expect(config.registration.set).to.equal('on');
-    });
-
-    it('should parse SERVER_PORT as integer', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.serverSettings.port).to.equal(3000);
-    });
-
-    it('should split API_KEYS into array', () => {
-      const config = setConfig(basePack, baseOptions);
-      expect(config.security.apiKeys).to.deep.equal(['testKey1', 'testKey2']);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - MongoDB
-  // ----------------------------------------------------------
-  describe('setConfig - mongodb', () => {
-    it('should throw when DATABASE_NAME is not set', async () => {
-      const { mod, savedEnv } = await importModule();
-      expect(() => mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      })).to.throw('Errors in configuration');
-      restoreEnv(savedEnv);
-    });
-
-    it('should set mongoSettings when DATABASE_NAME is set', async () => {
-      const { mod, savedEnv } = await importModule({ DATABASE_NAME: 'testdb' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings).to.be.an('object');
-      expect(config.mongoSettings.database).to.equal('testdb');
-      expect(config.mongoSettings.table).to.equal('test-table');
-      restoreEnv(savedEnv);
-    });
-
-    it('should use default domain localhost', async () => {
-      const { mod, savedEnv } = await importModule({ DATABASE_NAME: 'testdb' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.domain).to.equal('localhost');
-      expect(config.mongoSettings.url).to.include('mongodb://localhost/testdb');
-      restoreEnv(savedEnv);
-    });
-
-    it('should use mongodb+srv:// when MONGO_USE_SRV is yes', async () => {
-      const { mod, savedEnv } = await importModule({
-        DATABASE_NAME: 'testdb',
-        MONGO_USE_SRV: 'yes',
-      });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.url).to.include('mongodb+srv://');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include auth in URL when DATABASE_USER and DATABASE_PASSWORD are set', async () => {
-      const { mod, savedEnv } = await importModule({
-        DATABASE_NAME: 'testdb',
-        DATABASE_USER: 'admin',
-        DATABASE_PASSWORD: 'secret',
-      });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.url).to.include('admin:secret@');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include default pool sizes and timeouts', async () => {
-      const { mod, savedEnv } = await importModule({ DATABASE_NAME: 'testdb' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.options.family).to.equal(4);
-      expect(config.mongoSettings.options.socketTimeoutMS).to.equal(20000);
-      expect(config.mongoSettings.options.serverSelectionTimeoutMS).to.equal(30000);
-      expect(config.mongoSettings.options.heartbeatFrequencyMS).to.equal(10000);
-      expect(config.mongoSettings.connectTimeout).to.equal(30);
-      expect(config.mongoSettings.validationCheck).to.equal(1000);
-      expect(config.mongoSettings.reconnectOffset).to.equal(5);
-      restoreEnv(savedEnv);
-    });
-
-    it('should include SSL options in query string when MONGO_SSL is yes', async () => {
-      const { mod, savedEnv } = await importModule({
-        DATABASE_NAME: 'testdb',
-        MONGO_SSL: 'yes',
-      });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.stringOptions).to.include('ssl=true');
-      restoreEnv(savedEnv);
-    });
-
-    it('should set replicat flag when MONGO_REPLICAT_SET is set', async () => {
-      const { mod, savedEnv } = await importModule({
-        DATABASE_NAME: 'testdb',
-        MONGO_REPLICAT_SET: 'rs0',
-      });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'mongodb', table: 'test-table' },
-      });
-      expect(config.mongoSettings.replicat).to.equal(true);
-      expect(config.mongoSettings.stringOptions).to.include('replicaSet=rs0');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - DynamoDB
-  // ----------------------------------------------------------
-  describe('setConfig - dynamodb', () => {
-    it('should set dynamoose config with defaults', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        database: { type: 'dynamodb', table: 'test-table' },
-      });
-      expect(config.dynamoose).to.be.an('object');
-      expect(config.dynamoose.tableName).to.equal('test-table');
-      expect(config.dynamoose.region).to.equal('----noRegion----');
-      expect(config.dynamoose.url).to.equal('http://localhost:8000');
-      expect(config.dynamoose.throughput.read).to.equal(1);
-      expect(config.dynamoose.throughput.write).to.equal(1);
-      expect(config.dynamoose.schemaThroughput.read).to.equal(1);
-      expect(config.dynamoose.schemaThroughput.write).to.equal(1);
-      restoreEnv(savedEnv);
-    });
-
-    it('should use ON_DEMAND when DYNAMO_SCHEMA_THROUGHPUT is ON_DEMAND', async () => {
-      const { mod, savedEnv } = await importModule({ DYNAMO_SCHEMA_THROUGHPUT: 'ON_DEMAND' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'dynamodb', table: 'test-table' },
-      });
-      expect(config.dynamoose.schemaThroughput).to.equal('ON_DEMAND');
-      expect(config.dynamoose.throughput).to.equal(undefined);
-      restoreEnv(savedEnv);
-    });
-
-    it('should parse numeric DYNAMO_SCHEMA_THROUGHPUT', async () => {
-      const { mod, savedEnv } = await importModule({ DYNAMO_SCHEMA_THROUGHPUT: '10' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'dynamodb', table: 'test-table' },
-      });
-      expect(config.dynamoose.schemaThroughput).to.equal(10);
-      restoreEnv(savedEnv);
-    });
-
-    it('should fallback to 1 for non-numeric DYNAMO_SCHEMA_THROUGHPUT', async () => {
-      const { mod, savedEnv } = await importModule({ DYNAMO_SCHEMA_THROUGHPUT: 'abc' });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'dynamodb', table: 'test-table' },
-      });
-      expect(config.dynamoose.schemaThroughput).to.equal(1);
-      restoreEnv(savedEnv);
-    });
-
-    it('should include AWS credentials when set', async () => {
-      const { mod, savedEnv } = await importModule({
-        DYNAMODB_AWS_ACCESS_KEY_ID: 'test-key-id',
-        DYNAMODB_AWS_SECRET_ACCESS_KEY: 'test-secret',
-      });
-      const config = mod.setConfig(basePack, {
-        database: { type: 'dynamodb', table: 'test-table' },
-      });
-      expect(config.dynamoose.accessKeyId).to.equal('test-key-id');
-      expect(config.dynamoose.secretAccessKey).to.equal('test-secret');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Level DB
-  // ----------------------------------------------------------
-  describe('setConfig - level', () => {
-    it('should set levelSettings with dir and persist from options', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        database: { type: 'level', dir: '/tmp/level', persist: true },
-      });
-      expect(config.levelSettings).to.deep.equal({ dir: '/tmp/level', persist: true });
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - unsupported database type
-  // ----------------------------------------------------------
-  describe('setConfig - unsupported database type', () => {
-    it('should throw Error for unsupported database type', async () => {
-      const { mod, savedEnv } = await importModule();
-      expect(() => mod.setConfig(basePack, {
-        database: { type: 'sqlite' },
-      })).to.throw('database type not supported: sqlite');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Redis cache
-  // ----------------------------------------------------------
-  describe('setConfig - redis cache', () => {
-    it('should set redisSettings when cache.type is redis and CACHE_SET is on', async () => {
-      const { mod, savedEnv } = await importModule({
-        CACHE_SET: 'on',
-        CACHE_USER: 'user',
-        CACHE_PASSWORD: 'pass',
-      });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      expect(config.redisSettings).to.be.an('object');
-      expect(config.redisSettings.domain).to.equal('localhost:6379');
-      restoreEnv(savedEnv);
-    });
-
-    it('should not set redisSettings when CACHE_SET is off', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      expect(config.redisSettings).to.equal(undefined);
-      restoreEnv(savedEnv);
-    });
-
-    it('should throw for unsupported cache type', async () => {
-      const { mod, savedEnv } = await importModule({ CACHE_SET: 'on' });
-      expect(() => mod.setConfig(basePack, {
-        cache: { type: 'memcached' },
-      })).to.throw('cache type not supported: memcached');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include auth in URL when CACHE_USER and CACHE_PASSWORD are set', async () => {
-      const { mod, savedEnv } = await importModule({
-        CACHE_SET: 'on',
-        CACHE_USER: 'redisuser',
-        CACHE_PASSWORD: 'redispass',
-      });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      expect(config.redisSettings.url).to.include('redisuser:redispass@');
-      restoreEnv(savedEnv);
-    });
-
-    it('should use default TTL values', async () => {
-      const { mod, savedEnv } = await importModule({ CACHE_SET: 'on', CACHE_USER: 'user', CACHE_PASSWORD: 'pass' });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      expect(config.redisSettings.api.idTTL).to.equal(20);
-      expect(config.redisSettings.api.optionTTL).to.equal(5);
-      expect(config.redisSettings.connectTimeout).to.equal(30);
-      expect(config.redisSettings.request.TTL).to.equal(10);
-      expect(config.redisSettings.validationCheck).to.equal(1000);
-      expect(config.redisSettings.reconnectOffset).to.equal(5);
-      restoreEnv(savedEnv);
-    });
-
-    it('should configure cluster settings', async () => {
-      const { mod, savedEnv } = await importModule({
-        CACHE_SET: 'on',
-        CACHE_USER: 'user',
-        CACHE_PASSWORD: 'pass',
-        CACHE_CLUSTER_SET: 'on',
-        CACHE_CLUSTER_USE_REPLICAS: 'on',
-        CACHE_CLUSTER_MINIMIZE_CONNECTION: 'on',
-      });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      expect(config.redisSettings.cluster.set).to.equal('on');
-      expect(config.redisSettings.cluster.useReplicas).to.equal('on');
-      expect(config.redisSettings.cluster.minimizeConnections).to.equal('on');
-      restoreEnv(savedEnv);
-    });
-
-    it('should have a reconnectStrategy that returns interval on retry', async () => {
-      const { mod, savedEnv } = await importModule({ CACHE_SET: 'on', CACHE_USER: 'user', CACHE_PASSWORD: 'pass' });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      const strategy = config.redisSettings.options.socket.reconnectStrategy;
-      const result = strategy({ timesConnected: 1, attempt: 5 });
-      expect(result).to.equal(500);
-      restoreEnv(savedEnv);
-    });
-
-    it('should have a reconnectStrategy that returns undefined when no retry conditions met', async () => {
-      const { mod, savedEnv } = await importModule({ CACHE_SET: 'on', CACHE_USER: 'user', CACHE_PASSWORD: 'pass' });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      const strategy = config.redisSettings.options.socket.reconnectStrategy;
-      const result = strategy({ timesConnected: 0, attempt: 0 });
-      expect(result).to.equal(undefined);
-      restoreEnv(savedEnv);
-    });
-
-    it('should have a reconnectStrategy that calls logger.error on ECONNREFUSED', async () => {
-      resetStubs();
-      const { mod, savedEnv } = await importModule({ CACHE_SET: 'on', CACHE_USER: 'user', CACHE_PASSWORD: 'pass' });
-      const config = mod.setConfig(basePack, {
-        cache: { type: 'redis' },
-      });
-      const strategy = config.redisSettings.options.socket.reconnectStrategy;
-      strategy({ timesConnected: 0, attempt: 0, error: { code: 'ECONNREFUSED' } });
-      expect(mockLogger.error.calledOnce).to.equal(true);
-      expect(mockLogger.flushAndExit.calledOnce).to.equal(true);
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Topic
-  // ----------------------------------------------------------
-  describe('setConfig - topic', () => {
-    it('should set topicSettings when topic is provided and TOPIC_SET is on', async () => {
-      const { mod, savedEnv } = await importModule({ TOPIC_SET: 'on' });
-      const config = mod.setConfig(basePack, {
-        topic: { name: 'test-topic' },
-      });
-      expect(config.topicSettings).to.be.an('object');
-      expect(config.topicSettings.name).to.equal('test-topic');
-      expect(config.topicSettings.region).to.equal('----noRegion----');
-      restoreEnv(savedEnv);
-    });
-
-    it('should not set topicSettings when TOPIC_SET is off', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        topic: { name: 'test-topic' },
-      });
-      expect(config.topicSettings).to.equal(undefined);
-      restoreEnv(savedEnv);
-    });
-
-    it('should set isFifoTopic when SET_SNS_TOPIC_FIFO is yes', async () => {
-      const { mod, savedEnv } = await importModule({
-        TOPIC_SET: 'on',
-        SET_SNS_TOPIC_FIFO: 'yes',
-      });
-      const config = mod.setConfig(basePack, {
-        topic: { name: 'test-topic' },
-      });
-      expect(config.topicSettings.isFifoTopic).to.equal(true);
-      restoreEnv(savedEnv);
-    });
-
-    it('should set contentBasedDeduplication when fifo and SET_SNS_CONTENT_DEDUPLICATION is yes', async () => {
-      const { mod, savedEnv } = await importModule({
-        TOPIC_SET: 'on',
-        SET_SNS_TOPIC_FIFO: 'yes',
-        SET_SNS_CONTENT_DEDUPLICATION: 'yes',
-      });
-      const config = mod.setConfig(basePack, {
-        topic: { name: 'test-topic' },
-      });
-      expect(config.topicSettings.contentBasedDeduplication).to.equal(true);
-      restoreEnv(savedEnv);
-    });
-
-    it('should include AWS credentials when set', async () => {
-      const { mod, savedEnv } = await importModule({
-        TOPIC_SET: 'on',
-        SNS_AWS_ACCESS_KEY_ID: 'sns-key',
-        SNS_AWS_SECRET_ACCESS_KEY: 'sns-secret',
-      });
-      const config = mod.setConfig(basePack, {
-        topic: { name: 'test-topic' },
-      });
-      expect(config.topicSettings.accessKeyId).to.equal('sns-key');
-      expect(config.topicSettings.secretAccessKey).to.equal('sns-secret');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Encryption
-  // ----------------------------------------------------------
-  describe('setConfig - encryption', () => {
-    it('should setup encryption when ENCRYPTION_SET is on', async () => {
-      const { mod, savedEnv } = await importModule({
-        ENCRYPTION_SET: 'on',
-        ENCRYPTION_DATABASE: 'admin',
-        KEY_VAULT_TABLE: 'keystore',
-        LOCAL_MASTER_KEY: 'test-local-master-key',
-      });
-      const config = mod.setConfig(basePack, {
-        encryption: { set: 'on', keys: {} },
-      });
-      expect(config.encryption).to.be.an('object');
-      expect(config.encryption.database).to.equal('admin');
-      expect(config.encryption.keyVaultTable).to.equal('keystore');
-      expect(config.encryption.kmsProvider).to.equal('local');
-      restoreEnv(savedEnv);
-    });
-
-    it('should configure AWS KMS when kmsProvider is aws', async () => {
-      const { mod, savedEnv } = await importModule({
-        ENCRYPTION_SET: 'on',
-        ENCRYPTION_DATABASE: 'admin',
-        KEY_VAULT_TABLE: 'keystore',
-        KMS_PROVIDER: 'aws',
-        MASTER_KEY_AWS_REGION: 'us-east-1',
-        MASTER_KEY_ARN: 'arn:aws:kms:us-east-1:123:key/abc',
-        ENCRYPTION_ACCESS_KEY_ID: 'enc-key',
-        ENCRYPTION_SECRET_ACCESS_KEY: 'enc-secret',
-      });
-      const config = mod.setConfig(basePack, {
-        encryption: { set: 'on', keys: {} },
-      });
-      expect(config.encryption.kmsProvider).to.equal('aws');
-      expect(config.encryption.region).to.equal('us-east-1');
-      expect(config.encryption.masterKeyARN).to.equal('arn:aws:kms:us-east-1:123:key/abc');
-      expect(config.encryption.aws.accessKeyId).to.equal('enc-key');
-      expect(config.encryption.aws.secretAccessKey).to.equal('enc-secret');
-      restoreEnv(savedEnv);
-    });
-
-    it('should use local master key when kmsProvider is local', async () => {
-      const { mod, savedEnv } = await importModule({
-        ENCRYPTION_SET: 'on',
-        ENCRYPTION_DATABASE: 'admin',
-        KEY_VAULT_TABLE: 'keystore',
-        LOCAL_MASTER_KEY: 'local-master-key-value',
-      });
-      const config = mod.setConfig(basePack, {
-        encryption: { set: 'on', keys: {} },
-      });
-      expect(config.encryption.localMasterKey).to.equal('local-master-key-value');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include encryption keys when provided', async () => {
-      const { mod, savedEnv } = await importModule({
-        ENCRYPTION_SET: 'on',
-        ENCRYPTION_DATABASE: 'admin',
-        KEY_VAULT_TABLE: 'keystore',
-        LOCAL_MASTER_KEY: 'test-local-master-key',
-      });
-      const keys = { field1: 'keyId1', field2: 'keyId2' };
-      const config = mod.setConfig(basePack, {
-        encryption: { set: 'on', keys },
-      });
-      expect(config.encryption.keys).to.deep.equal(keys);
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - User Definitions
-  // ----------------------------------------------------------
-  describe('setConfig - userDefinitions', () => {
-    it('should return default userDefinitions when file is "not set"', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        userDefinitions: { file: 'not set' },
-      });
-      expect(config.userDefinitions.file).to.equal('not set');
-      expect(config.userDefinitions.all).to.deep.equal(mockUserDefinitions.all);
-      restoreEnv(savedEnv);
-    });
-
-    it('should merge custom definitions from a valid JSON file', async () => {
-      const customDefs = { custom: { attributes: ['email'] } };
-      const mod = await esmock('../index.js', {
-        '@mimik/sumologic-winston-logger': { default: mockLogger },
-        '@mimik/request-helper': { getCorrelationId: mockGetCorrelationId },
-        '@mimik/user-filters': { userDefinitions: mockUserDefinitions },
-        'ip': { address: mockIpAddress },
-        'node:fs': {
-          readFileSync: stub().returns(Buffer.from(JSON.stringify(customDefs))),
-        },
-      });
-      const config = mod.setConfig(basePack, {
-        userDefinitions: { file: '/path/to/definitions.json' },
-      });
-      expect(config.userDefinitions.custom).to.deep.equal(customDefs.custom);
-      expect(config.userDefinitions.file).to.equal('/path/to/definitions.json');
-    });
-
-    it('should throw Error when file read fails', async () => {
-      const mod = await esmock('../index.js', {
-        '@mimik/sumologic-winston-logger': { default: mockLogger },
-        '@mimik/request-helper': { getCorrelationId: mockGetCorrelationId },
-        '@mimik/user-filters': { userDefinitions: mockUserDefinitions },
-        'ip': { address: mockIpAddress },
-        'node:fs': {
-          readFileSync: stub().throws(new Error('ENOENT: no such file')),
-        },
-      });
-      expect(() => mod.setConfig(basePack, {
-        userDefinitions: { file: '/bad/path.json' },
-      })).to.throw('Invalid file for user definitions');
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Dependencies
-  // ----------------------------------------------------------
-  describe('setConfig - dependencies', () => {
-    it('should merge dependencies when isMSTSet is true', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        dependencies: {
-          mCustom: { url: 'http://custom:8080', audience: 'custom-aud' },
-        },
-      });
-      expect(config.dependencies.mCustom).to.deep.equal({
-        url: 'http://custom:8080',
-        audience: 'custom-aud',
-      });
-      restoreEnv(savedEnv);
-    });
-
-    it('should only include url and apiKey when isMSTSet is false and apiKey exists', async () => {
-      const { mod, savedEnv } = await importModule({
-        MST_SET: 'off',
-        API_KEYS: 'testKey1',
-      });
-      const config = mod.setConfig(basePack, {
-        dependencies: {
-          mCustom: { url: 'http://custom:8080', apiKey: 'key123', audience: 'custom-aud' },
-        },
-      });
-      expect(config.dependencies.mCustom).to.deep.equal({
-        url: 'http://custom:8080',
-        apiKey: 'key123',
-      });
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - Custom and Security
-  // ----------------------------------------------------------
-  describe('setConfig - custom options', () => {
-    it('should merge custom properties into configuration', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        custom: { myCustomProp: { key: 'value' } },
-      });
-      expect(config.myCustomProp).to.deep.equal({ key: 'value' });
-      restoreEnv(savedEnv);
-    });
-  });
-
-  describe('setConfig - security options', () => {
-    it('should merge into existing security sections', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        security: { admin: { role: 'superadmin' } },
-      });
-      expect(config.security.admin.role).to.equal('superadmin');
-      expect(config.security.admin.externalId).to.equal('admin');
-      restoreEnv(savedEnv);
-    });
-
-    it('should add new security sections', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, {
-        security: { customAuth: { provider: 'oauth2' } },
-      });
-      expect(config.security.customAuth).to.deep.equal({ provider: 'oauth2' });
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setConfig - MST_SET off
-  // ----------------------------------------------------------
-  describe('setConfig - MST_SET off', () => {
-    it('should disable registration and cluster when MST_SET is off', async () => {
-      const { mod, savedEnv } = await importModule({
-        MST_SET: 'off',
-        API_KEYS: 'testKey1',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.registration.set).to.equal('off');
-      expect(config.cluster.management).to.equal('off');
-      restoreEnv(savedEnv);
-    });
-
-    it('should clear security.server when MST_SET is off', async () => {
-      const { mod, savedEnv } = await importModule({
-        MST_SET: 'off',
-        API_KEYS: 'testKey1',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.security.server).to.deep.equal({});
-      restoreEnv(savedEnv);
-    });
-
-    it('should throw when MST_SET is off and apiKeys is empty', async () => {
-      const { mod, savedEnv } = await importModule({
-        MST_SET: 'off',
-        API_KEYS: undefined,
-      });
-      expect(() => mod.setConfig(basePack, baseOptions))
-        .to.throw('Errors in configuration');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setupLog (called during module load)
-  // ----------------------------------------------------------
-  describe('setupLog', () => {
-    it('should default to sumologic mode', async () => {
-      const { mod, savedEnv } = await importModule({
-        LOG_MODE: 'sumologic',
-        SUMO_LOGIC_ENDPOINT: 'https://sumo.test',
-        SUMO_LOGIC_COLLECTOR_CODE: 'collector-123',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.logInfo.mode).to.equal('sumologic');
-      expect(config.logInfo.sumologic).to.be.an('object');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include awsS3 config when LOG_MODE is awsS3', async () => {
-      const { mod, savedEnv } = await importModule({
-        LOG_MODE: 'awsS3',
-        S3_AWS_REGION: 'us-east-1',
-        S3_AWS_BUCKET_NAME: 'test-bucket',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.logInfo.mode).to.equal('awsS3');
-      expect(config.logInfo.awsS3).to.be.an('object');
-      expect(config.logInfo.sumologic).to.equal(undefined);
-      restoreEnv(savedEnv);
-    });
-
-    it('should include both sumologic and awsS3 when LOG_MODE is all', async () => {
-      const { mod, savedEnv } = await importModule({
-        LOG_MODE: 'all',
-        SUMO_LOGIC_ENDPOINT: 'https://sumo.test',
-        SUMO_LOGIC_COLLECTOR_CODE: 'collector-123',
-        S3_AWS_REGION: 'us-east-1',
-        S3_AWS_BUCKET_NAME: 'test-bucket',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.logInfo.mode).to.equal('all');
-      expect(config.logInfo.sumologic).to.be.an('object');
-      expect(config.logInfo.awsS3).to.be.an('object');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include S3 AWS credentials when set', async () => {
-      const { mod, savedEnv } = await importModule({
-        LOG_MODE: 'awsS3',
-        S3_AWS_REGION: 'us-east-1',
-        S3_AWS_BUCKET_NAME: 'test-bucket',
-        S3_AWS_ACCESS_KEY_ID: 's3-key',
-        S3_AWS_SECRET_ACCESS_KEY: 's3-secret',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.logInfo.awsS3.accessKeyId).to.equal('s3-key');
-      expect(config.logInfo.awsS3.secretAccessKey).to.equal('s3-secret');
-      restoreEnv(savedEnv);
-    });
-
-    it('should use default exit delay and noStack', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.logInfo.exitDelay).to.equal(2000);
-      expect(config.logInfo.noStack).to.equal('yes');
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // setupLocationProvider (called during module load)
-  // ----------------------------------------------------------
-  describe('setupLocationProvider', () => {
-    it('should return noPublic when LOCATION_PROVIDER is not set', async () => {
-      const { mod, savedEnv } = await importModule();
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.locationProvider).to.equal('noPublic');
-      restoreEnv(savedEnv);
-    });
-
-    it('should return "environment" when LOCATION_PROVIDER is "environment"', async () => {
-      const { mod, savedEnv } = await importModule({ LOCATION_PROVIDER: 'environment' });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.locationProvider).to.equal('environment');
-      restoreEnv(savedEnv);
-    });
-
-    it('should return URL object when LOCATION_PROVIDER is a custom URL', async () => {
-      const { mod, savedEnv } = await importModule({ LOCATION_PROVIDER: 'https://geo.api.com' });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.locationProvider).to.deep.equal({ url: 'https://geo.api.com' });
-      restoreEnv(savedEnv);
-    });
-
-    it('should include key when LOCATION_PROVIDER_KEY is set', async () => {
-      const { mod, savedEnv } = await importModule({
-        LOCATION_PROVIDER: 'https://geo.api.com',
-        LOCATION_PROVIDER_KEY: 'abc123',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.locationProvider).to.deep.equal({
-        url: 'https://geo.api.com',
-        key: 'abc123',
-      });
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // checkConfig
-  // ----------------------------------------------------------
-  describe('checkConfig', () => {
-    it('should not throw when all required values are present', async () => {
-      const { mod, savedEnv } = await importModule();
-      expect(() => mod.setConfig(basePack, baseOptions)).to.not.throw();
-      restoreEnv(savedEnv);
-    });
-
-    it('should throw when required configuration values are undefined', async () => {
-      const { mod, savedEnv } = await importModule({
-        OAUTH_CLIENT_ID: undefined,
-      });
-      resetStubs();
-      expect(() => mod.setConfig(basePack, baseOptions))
-        .to.throw('Errors in configuration');
-      expect(mockLogger.error.calledOnce).to.equal(true);
-      restoreEnv(savedEnv);
-    });
-  });
-
-  // ----------------------------------------------------------
-  // Conditional config properties
-  // ----------------------------------------------------------
-  describe('Conditional configuration properties', () => {
-    it('should include apiBasicAuth when BITBUCKET_USERNAME is set', async () => {
-      const { mod, savedEnv } = await importModule({
-        BITBUCKET_USERNAME: 'testuser',
-        BITBUCKET_PASSWORD: 'testpass',
-      });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.serverSettings.apiBasicAuth).to.deep.equal({
-        username: 'testuser',
-        password: 'testpass',
-      });
-      restoreEnv(savedEnv);
-    });
-
-    it('should include apiApiKey when SWAGGERHUB_API_KEY is set', async () => {
-      const { mod, savedEnv } = await importModule({ SWAGGERHUB_API_KEY: 'test-key' });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.serverSettings.apiApiKey).to.equal('test-key');
-      restoreEnv(savedEnv);
-    });
-
-    it('should include generic.previousKey when OAUTH_GENERIC_PREVIOUS_KEY is set', async () => {
-      const { mod, savedEnv } = await importModule({ OAUTH_GENERIC_PREVIOUS_KEY: 'prev-key' });
-      const config = mod.setConfig(basePack, baseOptions);
-      expect(config.security.generic.previousKey).to.equal('prev-key');
-      restoreEnv(savedEnv);
-    });
-  });
-});

package/test/testEnv.js

@@ -1,46 +0,0 @@
-/* eslint no-process-env: "off" */
-import process from 'node:process';
-
-/**
- * The following environment variables are set for the test:
- *
- * | Env variable name | Description | Default | Comments |
- * | ----------------- | ----------- | ------- | -------- |
- * | SUMO_LOGIC_ENDPOINT | endpoint to use to log on sumologic | null
- * | SUMO_LOGIC_COLLECTOR_CODE | code to use to log on sumologic | null
- * | NO_STACK | flag to have a stack associated with the log | yes
- * | LOG_LEVEL | log level to log | error
- * | CONSOLE_LEVEL | log level to display | debug
- * | LOG_MODE | log mode | none
- * | MST_SET | to setup configuration without mST | on
- * | API_KEYS | list of API Keys | testKey1,testKey2
- * | SERVER_PORT | port of the server | 3000
- * | OAUTH_CLIENT_ID | security id | test-client-id
- * | OAUTH_CLIENT_SECRET | secret | test-client-secret
- * | OAUTH_CLIENT_ACCESS_KEY | access key | test-access-key
- * | OAUTH_CLIENT_AUDIENCE | audience | test-audience
- * | OAUTH_ISSUER | issuer | test-issuer
- * | MIT_URL | mIT URL | http://localhost:8080
- * | MIT_AUDIENCE | mIT audience | test-mit-audience
- */
-
-delete process.env.SUMO_LOGIC_ENDPOINT;
-delete process.env.SUMO_LOGIC_COLLECTOR_CODE;
-process.env.NO_STACK = 'yes';
-process.env.LOG_LEVEL = 'error';
-process.env.LOG_MODE = 'none';
-process.env.CONSOLE_LEVEL = 'debug';
-
-process.env.MST_SET = 'on';
-process.env.API_KEYS = 'testKey1,testKey2';
-process.env.SERVER_PORT = '3000';
-process.env.OAUTH_CLIENT_ID = 'test-client-id';
-process.env.OAUTH_CLIENT_SECRET = 'test-client-secret';
-process.env.OAUTH_CLIENT_ACCESS_KEY = 'test-access-key';
-process.env.OAUTH_CLIENT_AUDIENCE = 'test-audience';
-process.env.OAUTH_ISSUER = 'test-issuer';
-process.env.MIT_URL = 'http://localhost:8080';
-process.env.MIT_AUDIENCE = 'test-mit-audience';
-
-// Server type audience for basePack.mimik.type = 'mTest'
-process.env.MTEST_AUDIENCE = 'test-mtest-audience';